fix perf excludedLines lookup

Author: fflaten

src/documentParser.ts

@@ -5,6 +5,7 @@ export class DocumentParser {
     // Used to avoid calling symbol provider for the same document on every stopped location
     private readonly functionCache: Map<string, vscode.DocumentSymbol[]> = new Map<string, vscode.DocumentSymbol[]>();
 
+    // Clear cache between debugsessions to get updated symbols
     clearFunctionCache(): void {
         this.functionCache.clear();
     }
@@ -54,23 +55,21 @@ export class DocumentParser {
         return Math.max(0, ...functions.map(fn => fn.range.start.line));
     }
 
-    async getExcludedLines(document: vscode.TextDocument, stoppedLocation: vscode.Range, startLine: number): Promise<number[]> {
+    async getExcludedLines(document: vscode.TextDocument, stoppedLocation: vscode.Range, startLine: number): Promise<Set<number>> {
         const functions = await this.getFunctionsInDocument(document);
         const stoppedEnd = stoppedLocation.end.line;
         const excludedLines = [];
 
         for (var i = 0, length = functions.length; i < length; ++i) {
             const func = functions[i];
             // startLine (either document start or closest function start) are provided, so functions necessary to exclude
-            // will always start >= documentStart or after currentFunction start if nested function.
+            // will always start >= documentStart or same as currentFunction start if nested function.
             // Don't bother checking functions before startLine or after stoppedLocation
-            if (func.range.start.line >= startLine && func.range.start.line < stoppedEnd && !func.range.contains(stoppedLocation)) {
+            if (func.range.start.line >= startLine && func.range.start.line <= stoppedEnd && !func.range.contains(stoppedLocation)) {
                 const functionRange = utils.range(func.range.start.line, func.range.end.line);
-                excludedLines.push(...functionRange.filter(line => line < stoppedLocation.start.line || line > stoppedEnd));
+                excludedLines.push(...functionRange);
             }
         }
-
-        return excludedLines;
+        return new Set(excludedLines.filter(line => line < stoppedLocation.start.line || line > stoppedEnd));
     }
-
 }

src/powerShellVariableInlineValuesProvider.ts

@@ -17,8 +17,7 @@ export class PowerShellVariableInlineValuesProvider implements vscode.InlineValu
         `(?:\\$(?:[a-zA-Z]+:)?${this.alphanumChars}+)`, // Scoped or normal variables
     ].join('|'), 'giu'); // u flag to support unicode char classes
 
-    // Cache for symbols per document in the current debugsessions
-    private documentParser: DocumentParser;
+    private readonly documentParser: DocumentParser;
 
     constructor(documentParser: DocumentParser) {
         this.documentParser = documentParser;
@@ -35,7 +34,7 @@ export class PowerShellVariableInlineValuesProvider implements vscode.InlineValu
 
         for (let l = startLine; l <= endLine; l++) {
             // Exclude lines out of scope (other functions)
-            if (excludedLines.includes(l)) {
+            if (excludedLines.has(l)) {
                 continue;
             }
 

src/test/suite/documentParser.test.ts

@@ -137,14 +137,14 @@ test1
             });
 
             const result = await parser.getExcludedLines(doc, new vscode.Range(11, 0, 11, 3), 0);
-            assert.strictEqual(result.length, 7);
-            assert.strictEqual(result[0], 2);
-            assert.strictEqual(result[1], 3);
-            assert.strictEqual(result[2], 4);
-            assert.strictEqual(result[3], 5);
-            assert.strictEqual(result[4], 7);
-            assert.strictEqual(result[5], 8);
-            assert.strictEqual(result[6], 9);
+            assert.strictEqual(result.size, 7);
+            assert.strictEqual(result.has(2), true);
+            assert.strictEqual(result.has(3), true);
+            assert.strictEqual(result.has(4), true);
+            assert.strictEqual(result.has(5), true);
+            assert.strictEqual(result.has(7), true);
+            assert.strictEqual(result.has(8), true);
+            assert.strictEqual(result.has(9), true);
         });
 
         test('returns empty array when no functions out of scope are present in range', async () => {
@@ -168,7 +168,37 @@ test2
             });
 
             const result = await parser.getExcludedLines(doc, new vscode.Range(8, 4, 8, 7), 7);
-            assert.strictEqual(result.length, 0);
+            assert.strictEqual(result.size, 0);
+        });
+
+        test('does not exclude stoppedLocation multi-range', async () => {
+            const doc = await vscode.workspace.openTextDocument({
+                language: 'powershell',
+                content: `
+function test2 {
+    $b # Stopped location
+}; $param = @{ # Stopped location
+    Abc = 123 # Stopped location
+} # Stopped location
+`,
+            });
+
+            const result = await parser.getExcludedLines(doc, new vscode.Range(3, 3, 5, 1), 0);
+            assert.strictEqual(result.size, 2);
+            assert.strictEqual(result.has(1), true);
+            assert.strictEqual(result.has(2), true);
+        });
+
+        test('does not exclude stoppedLocation line when same as out of scope function', async () => {
+            const doc = await vscode.workspace.openTextDocument({
+                language: 'powershell',
+                content: `
+function test1 { }; $b; function test2 { }; #$b is stoppedLocation
+`,
+            });
+
+            const result = await parser.getExcludedLines(doc, new vscode.Range(1, 20, 1, 25), 0);
+            assert.strictEqual(result.size, 0);
         });
     });
 });