Configuration codelenses in source files don't draw if a config exists (#1123)

If an in-source file already has a launch.json entry that matches the root and handler that a CodeLens would produce, we no longer draw the CodeLens. This is similar to the behavior for CodeLenses in template files.

Author: bryceitoc9

src/shared/codelens/codeLensUtils.ts

@@ -3,6 +3,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import * as path from 'path'
 import * as vscode from 'vscode'
 
 import { CloudFormation } from '../cloudformation/cloudformation'
@@ -18,6 +19,7 @@ import { ExtContext } from '../extensions'
 import { recordLambdaInvokeLocal, Result, Runtime } from '../telemetry/telemetry'
 import { nodeJsRuntimes, RuntimeFamily } from '../../lambda/models/samLambdaRuntime'
 import { CODE_TARGET_TYPE } from '../sam/debugger/awsSamDebugConfiguration'
+import { getReferencedHandlerPaths, LaunchConfiguration } from '../debug/launchConfiguration'
 
 export type Language = 'python' | 'javascript' | 'csharp'
 
@@ -46,6 +48,7 @@ export async function makeCodeLenses({
     }
 
     const lenses: vscode.CodeLens[] = []
+    const existingConfigs = getReferencedHandlerPaths(new LaunchConfiguration(document.uri))
     for (const handler of handlers) {
         // handler.range is a RangeOrCharOffset union type. Extract vscode.Range.
         const range =
@@ -63,7 +66,9 @@ export async function makeCodeLenses({
                 rootUri: handler.manifestUri,
                 runtimeFamily,
             }
-            lenses.push(makeAddCodeSamDebugCodeLens(baseParams))
+            if (!existingConfigs.has(path.join(path.dirname(baseParams.rootUri.fsPath), baseParams.handlerName))) {
+                lenses.push(makeAddCodeSamDebugCodeLens(baseParams))
+            }
         } catch (err) {
             getLogger().error(
                 `Could not generate 'configure' code lens for handler '${handler.handlerName}'`,

src/shared/codelens/samTemplateCodeLensProvider.ts

@@ -6,15 +6,10 @@
 import * as _ from 'lodash'
 import * as vscode from 'vscode'
 import { TemplateFunctionResource, TemplateSymbolResolver } from '../cloudformation/templateSymbolResolver'
-import { LaunchConfiguration } from '../debug/launchConfiguration'
-import {
-    isTemplateTargetProperties,
-    TemplateTargetProperties,
-    TEMPLATE_TARGET_TYPE,
-} from '../sam/debugger/awsSamDebugConfiguration'
+import { getReferencedTemplateResources, LaunchConfiguration } from '../debug/launchConfiguration'
+import { TEMPLATE_TARGET_TYPE } from '../sam/debugger/awsSamDebugConfiguration'
 import { AddSamDebugConfigurationInput } from '../sam/debugger/commands/addSamDebugConfiguration'
 import { localize } from '../utilities/vsCodeUtils'
-import * as pathutils from '../utilities/pathUtils'
 
 /**
  * Provides Code Lenses for generating debug configurations for SAM templates.
@@ -31,7 +26,7 @@ export class SamTemplateCodeLensProvider implements vscode.CodeLensProvider {
             return []
         }
 
-        const existingDebuggedResources = getExistingDebuggedResources(document.uri, launchConfig)
+        const existingDebuggedResources = getReferencedTemplateResources(launchConfig)
 
         return _(functionResources)
             .reject(functionResource => existingDebuggedResources.has(functionResource.name))
@@ -52,21 +47,3 @@ export class SamTemplateCodeLensProvider implements vscode.CodeLensProvider {
         })
     }
 }
-
-function getExistingDebuggedResources(templateUri: vscode.Uri, launchConfig: LaunchConfiguration): Set<string> {
-    const existingSamDebugTargets = getExistingSamDebugTargets(launchConfig)
-    const folder = vscode.workspace.getWorkspaceFolder(templateUri)
-
-    return _(existingSamDebugTargets)
-        .filter(target => pathutils.areEqual(folder?.uri.fsPath, target.samTemplatePath, templateUri.fsPath))
-        .map(target => target.samTemplateResource)
-        .thru(array => new Set(array))
-        .value()
-}
-
-function getExistingSamDebugTargets(launchConfig: LaunchConfiguration): TemplateTargetProperties[] {
-    return _(launchConfig.getSamDebugConfigurations())
-        .map(samConfig => samConfig.invokeTarget)
-        .filter(isTemplateTargetProperties)
-        .value()
-}

src/shared/debug/launchConfiguration.ts

@@ -4,17 +4,24 @@
  */
 
 import * as _ from 'lodash'
+import * as path from 'path'
 import * as vscode from 'vscode'
+import { CloudFormationTemplateRegistry } from '../cloudformation/templateRegistry'
 import {
     AwsSamDebuggerConfiguration,
-    isAwsSamDebugConfiguration,
+    CodeTargetProperties,
     ensureRelativePaths,
+    isAwsSamDebugConfiguration,
+    isCodeTargetProperties,
+    isTemplateTargetProperties,
+    TemplateTargetProperties,
 } from '../sam/debugger/awsSamDebugConfiguration'
 import {
     AwsSamDebugConfigurationValidator,
     DefaultAwsSamDebugConfigurationValidator,
 } from '../sam/debugger/awsSamDebugConfigurationValidator'
-import { CloudFormationTemplateRegistry } from '../cloudformation/templateRegistry'
+import * as pathutils from '../utilities/pathUtils'
+import { tryGetAbsolutePath } from '../utilities/workspaceUtils'
 
 /**
  * Reads and writes DebugConfigurations.
@@ -28,17 +35,20 @@ export interface DebugConfigurationSource {
  * Wraps read and write operations on launch.json.
  */
 export class LaunchConfiguration {
+    public readonly workspaceFolder: vscode.WorkspaceFolder | undefined
     /**
      * Creates a Launch Configuration scoped to the given resource.
      */
     public constructor(
-        resource: vscode.Uri,
-        private readonly configSource: DebugConfigurationSource = new DefaultDebugConfigSource(resource),
+        public readonly scopedResource: vscode.Uri,
+        private readonly configSource: DebugConfigurationSource = new DefaultDebugConfigSource(scopedResource),
         private readonly samValidator: AwsSamDebugConfigurationValidator = new DefaultAwsSamDebugConfigurationValidator(
             CloudFormationTemplateRegistry.getRegistry(),
-            vscode.workspace.getWorkspaceFolder(resource)
+            vscode.workspace.getWorkspaceFolder(scopedResource)
         )
-    ) {}
+    ) {
+        this.workspaceFolder = vscode.workspace.getWorkspaceFolder(scopedResource)
+    }
 
     public getDebugConfigurations(): vscode.DebugConfiguration[] {
         return _(this.configSource.getDebugConfigurations())
@@ -84,3 +94,60 @@ class DefaultDebugConfigSource implements DebugConfigurationSource {
         await this.launch.update('configurations', value)
     }
 }
+
+function getSamTemplateTargets(launchConfig: LaunchConfiguration): TemplateTargetProperties[] {
+    return _(launchConfig.getSamDebugConfigurations())
+        .map(samConfig => samConfig.invokeTarget)
+        .filter(isTemplateTargetProperties)
+        .value()
+}
+
+function getSamCodeTargets(launchConfig: LaunchConfiguration): CodeTargetProperties[] {
+    return _(launchConfig.getSamDebugConfigurations())
+        .map(samConfig => samConfig.invokeTarget)
+        .filter(isCodeTargetProperties)
+        .value()
+}
+
+/**
+ * Returns a Set containing the samTemplateResources from the launch.json file that the launch config is scoped to.
+ * @param launchConfig Launch config to check
+ */
+export function getReferencedTemplateResources(launchConfig: LaunchConfiguration): Set<string> {
+    const existingSamTemplateTargets = getSamTemplateTargets(launchConfig)
+    const folder = launchConfig.workspaceFolder
+
+    return _(existingSamTemplateTargets)
+        .filter(target =>
+            pathutils.areEqual(folder?.uri.fsPath, target.samTemplatePath, launchConfig.scopedResource.fsPath)
+        )
+        .map(target => target.samTemplateResource)
+        .thru(array => new Set(array))
+        .value()
+}
+
+/**
+ * Returns a Set containing the full path for all `code`-type `aws-sam` debug configs in a launch.json file.
+ * The full path represents `path.join(workspaceFolder, projectRoot, lambdaHandler)`
+ * (without workspaceFolder if the projectRoot is relative).
+ * @param launchConfig Launch config to check
+ */
+export function getReferencedHandlerPaths(launchConfig: LaunchConfiguration): Set<string> {
+    const existingSamCodeTargets = getSamCodeTargets(launchConfig)
+
+    return _(existingSamCodeTargets)
+        .map(target => {
+            if (path.isAbsolute(target.projectRoot)) {
+                return pathutils.normalize(path.join(target.projectRoot, target.lambdaHandler))
+            }
+            return pathutils.normalize(
+                path.join(
+                    tryGetAbsolutePath(launchConfig.workspaceFolder, ''),
+                    target.projectRoot,
+                    target.lambdaHandler
+                )
+            )
+        })
+        .thru(array => new Set(array))
+        .value()
+}

src/test/shared/codelens/samTemplateCodeLensProvider.test.ts

@@ -65,6 +65,12 @@ describe('SamTemplateCodeLensProvider', async () => {
         mockLaunchConfig = mock()
 
         when(mockDocument.uri).thenReturn(templateUri)
+        when(mockLaunchConfig.scopedResource).thenReturn(templateUri)
+        when(mockLaunchConfig.workspaceFolder).thenReturn({
+            uri: templateUri,
+            name: 'notAWorkspaceFolder',
+            index: 1,
+        })
         when(mockLaunchConfig.getSamDebugConfigurations()).thenReturn(debugConfigurations)
     })