async function activateCodeLensProviders()

in src/shared/sam/activation.ts [152:247]
76 lines of code
4 McCabe index (conditional complexity)

async function activateCodeLensProviders(
    context: ExtContext,
    configuration: SettingsConfiguration,
    toolkitOutputChannel: vscode.OutputChannel,
    telemetryService: TelemetryService
): Promise<vscode.Disposable[]> {
    const disposables: vscode.Disposable[] = []
    const tsCodeLensProvider = codelensUtils.makeTypescriptCodeLensProvider(configuration)
    const pyCodeLensProvider = await codelensUtils.makePythonCodeLensProvider(configuration)
    const javaCodeLensProvider = await codelensUtils.makeJavaCodeLensProvider(configuration)
    const csCodeLensProvider = await codelensUtils.makeCSharpCodeLensProvider(configuration)
    const goCodeLensProvider = await codelensUtils.makeGoCodeLensProvider(configuration)

    // Ideally we should not need to `await` this Promise, but CodeLens providers are currently not implementing
    // the event to notify on when their results change.
    await activateCodeLensRegistry(context)

    const supportedLanguages: {
        [language: string]: codelensUtils.OverridableCodeLensProvider
    } = {
        [jsLensProvider.JAVASCRIPT_LANGUAGE]: tsCodeLensProvider,
        [pyLensProvider.PYTHON_LANGUAGE]: pyCodeLensProvider,
    }

    if (!isCloud9()) {
        supportedLanguages[javaLensProvider.JAVA_LANGUAGE] = javaCodeLensProvider
        supportedLanguages[csLensProvider.CSHARP_LANGUAGE] = csCodeLensProvider
        supportedLanguages[goLensProvider.GO_LANGUAGE] = goCodeLensProvider
    }

    disposables.push(
        vscode.languages.registerCodeLensProvider(
            [
                {
                    language: 'yaml',
                    scheme: 'file',
                    pattern: '**/*template.{yml,yaml}',
                },
            ],
            new SamTemplateCodeLensProvider()
        )
    )

    disposables.push(vscode.languages.registerCodeLensProvider(jsLensProvider.TYPESCRIPT_ALL_FILES, tsCodeLensProvider))
    disposables.push(vscode.languages.registerCodeLensProvider(pyLensProvider.PYTHON_ALLFILES, pyCodeLensProvider))
    disposables.push(vscode.languages.registerCodeLensProvider(javaLensProvider.JAVA_ALLFILES, javaCodeLensProvider))
    disposables.push(vscode.languages.registerCodeLensProvider(csLensProvider.CSHARP_ALLFILES, csCodeLensProvider))
    disposables.push(vscode.languages.registerCodeLensProvider(goLensProvider.GO_ALLFILES, goCodeLensProvider))

    disposables.push(
        vscode.commands.registerCommand('aws.toggleSamCodeLenses', () => {
            const toggled = !configuration.readSetting<boolean>(codelensUtils.STATE_NAME_ENABLE_CODELENSES)
            configuration.writeSetting(
                codelensUtils.STATE_NAME_ENABLE_CODELENSES,
                toggled,
                vscode.ConfigurationTarget.Global
            )
        })
    )

    disposables.push(
        vscode.commands.registerCommand('aws.addSamDebugConfig', async () => {
            const activeEditor = vscode.window.activeTextEditor
            if (!activeEditor) {
                getLogger().error(`aws.addSamDebugConfig was called without an active text editor`)
                vscode.window.showErrorMessage(
                    localize('AWS.pickDebugHandler.noEditor', 'Toolkit could not find an active editor')
                )

                return
            }
            const document = activeEditor.document
            const provider = supportedLanguages[document.languageId]
            if (!provider) {
                getLogger().error(
                    `aws.addSamDebugConfig called on a document with an invalid language: ${document.languageId}`
                )
                vscode.window.showErrorMessage(
                    localize(
                        'AWS.pickDebugHandler.invalidLanguage',
                        'Toolkit cannot detect handlers in language: {0}',
                        document.languageId
                    )
                )

                return
            }

            const lenses =
                (await provider.provideCodeLenses(document, new vscode.CancellationTokenSource().token, true)) ?? []
            codelensUtils.invokeCodeLensCommandPalette(document, lenses)
        })
    )

    return disposables
}