From c16017f81af160e3f17e2fbea0a1ff258d9949f8 Mon Sep 17 00:00:00 2001
From: Frode Flaten <3436158+fflaten@users.noreply.github.com>
Date: Fri, 3 Jun 2022 20:31:17 +0000
Subject: [PATCH 1/7] rewrite variable detection

---
 src/powerShellVariableInlineValuesProvider.ts | 28 +++++++++++--------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/src/powerShellVariableInlineValuesProvider.ts b/src/powerShellVariableInlineValuesProvider.ts
index f0f5578..51786f9 100644
--- a/src/powerShellVariableInlineValuesProvider.ts
+++ b/src/powerShellVariableInlineValuesProvider.ts
@@ -2,11 +2,21 @@ import * as vscode from 'vscode';
 
 export class PowerShellVariableInlineValuesProvider implements vscode.InlineValuesProvider {
 
+    // Known constants
+    private readonly ignoredVariables = /^\$(?:true|false|null)$/i;
+    
+    // Variable patterns
+    // https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_variables?view=powershell-5.1#variable-names-that-include-special-characters
+    private readonly alphanumChars = /(?:\p{Lu}|\p{Ll}|\p{Lt}|\p{Lm}|\p{Lo}|\p{Nd}|[_?])/.source;
+    private readonly variableRegex = new RegExp([
+        '(?:\\$\\{(.*?)(?<!`)\\})' // Special characters variables. Lazy match until unescaped }
+        ,`|(?:\\$${this.alphanumChars}+:${this.alphanumChars}+)` // Scoped variables
+        ,`|(?:\\$${this.alphanumChars}+)` // Normal variables
+    ].join(''), 'giu'); // u flag to support unicode char classes
+
     provideInlineValues(document: vscode.TextDocument, viewport: vscode.Range, context: vscode.InlineValueContext) : vscode.ProviderResult<vscode.InlineValue[]> {
         const allValues: vscode.InlineValue[] = [];
 
-        const ignoredVariables = /^\$(?:true|false|null)$/i;
-
         for (let l = 0; l <= context.stoppedLocation.end.line; l++) {
             const line = document.lineAt(l);
 
@@ -15,11 +25,10 @@ export class PowerShellVariableInlineValuesProvider implements vscode.InlineValu
                 continue;
             }
 
-            const variableMatches = /(?:\${(.*)})|(?:\$\S+:\S+)|(?:\$\S+)/gi;
-            for (let match = variableMatches.exec(line.text); match; match = variableMatches.exec(line.text)) {
-                // If we're looking at an "anything goes" variable, that has a capture group so use that instead
+            for (let match = this.variableRegex.exec(line.text); match; match = this.variableRegex.exec(line.text)) {
+                // If we're looking at special characters variable, use the variable name in capture group 1
                 let varName = match[0][1] === '{'
-                    ? '$' + match[1]
+                    ? '$' + match[1].replace(/`(.)/g,'$1') // Remove backticks used as escape char for curly braces, unicode etc.
                     : match[0];
 
                 // If there's a scope, we need to remove it
@@ -28,13 +37,8 @@ export class PowerShellVariableInlineValuesProvider implements vscode.InlineValu
                     varName = '$' + varName.substring(colon + 1);
                 }
 
-                // These characters need to be trimmed off
-                if ([';', ',', '-', '+', '/', '*'].includes(varName[varName.length - 1])) {
-                    varName = varName.substring(0, varName.length - 1);
-                }
-
                 // If known PowerShell constant, ignore
-                if (ignoredVariables.test(varName)) {
+                if (this.ignoredVariables.test(varName)) {
                     continue;
                 }
 

From fc6307a89e4facc8a87fce2043ff079d28abcecc Mon Sep 17 00:00:00 2001
From: Frode Flaten <3436158+fflaten@users.noreply.github.com>
Date: Fri, 3 Jun 2022 20:31:33 +0000
Subject: [PATCH 2/7] add tests

---
 src/test/suite/extension.test.ts | 405 +++++++++++++++++++++++++++++--
 1 file changed, 389 insertions(+), 16 deletions(-)

diff --git a/src/test/suite/extension.test.ts b/src/test/suite/extension.test.ts
index 3bea556..f255198 100644
--- a/src/test/suite/extension.test.ts
+++ b/src/test/suite/extension.test.ts
@@ -3,22 +3,20 @@ import * as assert from 'assert';
 import * as vscode from 'vscode';
 import { PowerShellVariableInlineValuesProvider } from '../../powerShellVariableInlineValuesProvider';
 
-suite('Extension Test Suite', async () => {
+suite('Variable detection', async () => {
 	vscode.window.showInformationMessage('Start all tests.');
 
 	test('Misc variable tests', async () => {
 		const doc = await vscode.workspace.openTextDocument({
 			language: 'powershell',
-			content: `$normal = Get-Process
+			content: `
+$normal = Get-Process
 $script:scoped = 5
-\${braces} = "asdf"
 $numb3rInside = 'asdf'
 $33333 = 'numbers'
-\${     } = 'spaces'
 $normal, \${braces}, $script:scoped
 4
-$true
-	`,
+`,
 		});
 
 		const provider = new PowerShellVariableInlineValuesProvider();
@@ -28,13 +26,13 @@ $true
 			frameId: 0
 		});
 
-		assert.strictEqual(result?.length, 9);
+		assert.strictEqual(result?.length, 7);
 		for (let i = 0; i < result.length; i++) {
 			const variable = result![i] as vscode.InlineValueVariableLookup;
 
 			let name: string = '';
 			let startChar: number = 0;
-			let line: number = i;
+			let line: number = i+1;
 			switch (i) {
 				case 0:
 					name = '$normal';
@@ -43,28 +41,403 @@ $true
 					name = '$scoped';
 					break;
 				case 2:
-					name = '$braces';
+					name = '$numb3rInside';
 					break;
 				case 3:
-					name = '$numb3rInside';
+					name = '$33333';
 					break;
 				case 4:
-					name = '$33333';
+					name = '$normal';
 					break;
 				case 5:
-					name = '$     ';
+					name = '$braces';
+					startChar = 9;
+					line = 5;
 					break;
 				case 6:
+					name = '$scoped';
+					startChar = 20;
+					line = 5;
+					break;
+			}
+		
+			assert.strictEqual(variable.caseSensitiveLookup, false);
+			assert.strictEqual(variable.range.start.line, line);
+			assert.strictEqual(variable.range.end.line, line);
+			assert.strictEqual(variable.range.start.character, startChar);
+			assert.strictEqual(variable.variableName, name);
+			assert.strictEqual(variable.range.end.character, name.length + startChar);
+		}
+	});
+
+	test('Known constants ignored', async () => {
+		const doc = await vscode.workspace.openTextDocument({
+			language: 'powershell',
+			content: '$false $true $null $123',
+		});
+
+		const provider = new PowerShellVariableInlineValuesProvider();
+
+		const result = await provider.provideInlineValues(doc, new vscode.Range(0, 0, 0, 0), {
+			stoppedLocation: new vscode.Range(doc.lineCount - 1, 0, doc.lineCount - 1, 0),
+			frameId: 0
+		});
+
+		assert.strictEqual(result?.length, 1);
+		
+		// Making sure the test actually ran by including a real variable
+		const variable = result![0] as vscode.InlineValueVariableLookup;
+		assert.strictEqual(variable.caseSensitiveLookup, false);
+		assert.strictEqual(variable.range.start.line, 0);
+		assert.strictEqual(variable.range.end.line, 0);
+		assert.strictEqual(variable.range.start.character, 19);
+		assert.strictEqual(variable.variableName, '$123');
+		assert.strictEqual(variable.range.end.character, (19 + 4));
+	});
+
+	test('Alphanumerical variables', async () => {
+		const doc = await vscode.workspace.openTextDocument({
+			language: 'powershell',
+			content: `
+$normal = Get-Process
+$numb3rInside = 'asdf'
+$33333 = 'numbers'
+$something_wrong? = 123
+4
+`,
+		});
+
+		const provider = new PowerShellVariableInlineValuesProvider();
+
+		const result = await provider.provideInlineValues(doc, new vscode.Range(0, 0, 0, 0), {
+			stoppedLocation: new vscode.Range(doc.lineCount - 1, 0, doc.lineCount - 1, 0),
+			frameId: 0
+		});
+
+		assert.strictEqual(result?.length, 4);
+		for (let i = 0; i < result.length; i++) {
+			const variable = result![i] as vscode.InlineValueVariableLookup;
+
+			let name: string = '';
+			let startChar: number = 0;
+			let line: number = i+1;
+			switch (i) {
+				case 0:
 					name = '$normal';
 					break;
-				case 7:
+				case 1:
+					name = '$numb3rInside';
+					break;
+				case 2:
+					name = '$33333';
+					break;
+				case 3:
+					name = '$something_wrong?';
+					break;
+			}
+		
+			assert.strictEqual(variable.caseSensitiveLookup, false);
+			assert.strictEqual(variable.range.start.line, line);
+			assert.strictEqual(variable.range.end.line, line);
+			assert.strictEqual(variable.range.start.character, startChar);
+			assert.strictEqual(variable.variableName, name);
+			assert.strictEqual(variable.range.end.character, name.length + startChar);
+		}
+	});
+
+	test('Scoped variables', async () => {
+		const doc = await vscode.workspace.openTextDocument({
+			language: 'powershell',
+			content: `
+$script:scoped = 5
+\${Script:special scoped}
+4
+`,
+		});
+
+		const provider = new PowerShellVariableInlineValuesProvider();
+
+		const result = await provider.provideInlineValues(doc, new vscode.Range(0, 0, 0, 0), {
+			stoppedLocation: new vscode.Range(doc.lineCount - 1, 0, doc.lineCount - 1, 0),
+			frameId: 0
+		});
+
+		assert.strictEqual(result?.length, 2);
+		for (let i = 0; i < result.length; i++) {
+			const variable = result![i] as vscode.InlineValueVariableLookup;
+
+			let name: string = '';
+			let startChar: number = 0;
+			let line: number = i+1;
+			switch (i) {
+				case 0:
+					name = '$scoped';
+					break;
+				case 1:
+					name = '$special scoped';
+					break;
+			}
+		
+			assert.strictEqual(variable.caseSensitiveLookup, false);
+			assert.strictEqual(variable.range.start.line, line);
+			assert.strictEqual(variable.range.end.line, line);
+			assert.strictEqual(variable.range.start.character, startChar);
+			assert.strictEqual(variable.variableName, name);
+			assert.strictEqual(variable.range.end.character, name.length + startChar);
+		}
+	});
+
+	test('Special character variables', async () => {
+		const doc = await vscode.workspace.openTextDocument({
+			language: 'powershell',
+			content: `
+\${hello\`\`b}
+\${braces} = "asdf"
+\${     } = 'spaces'
+\${Script:omg\`b}
+\${bra%!c\\e\`}<s} = 'special'
+`,
+		});
+
+		const provider = new PowerShellVariableInlineValuesProvider();
+
+		const result = await provider.provideInlineValues(doc, new vscode.Range(0, 0, 0, 0), {
+			stoppedLocation: new vscode.Range(doc.lineCount - 1, 0, doc.lineCount - 1, 0),
+			frameId: 0
+		});
+
+		assert.strictEqual(result?.length, 5);
+		for (let i = 0; i < result.length; i++) {
+			const variable = result![i] as vscode.InlineValueVariableLookup;
+
+			let name: string = '';
+			let startChar: number = 0;
+			let line: number = i+1;
+			switch (i) {
+				case 0:
+					name = '$hello`b';
+					break;
+				case 1:
+					name = '$braces';
+					break;
+				case 2:
+					name = '$     ';
+					break;
+				case 3:
+					name = '$omgb';
+					break;
+				case 4:
+					name = '$bra%!c\\e}<s';
+					break;
+			}
+		
+			assert.strictEqual(variable.caseSensitiveLookup, false);
+			assert.strictEqual(variable.range.start.line, line);
+			assert.strictEqual(variable.range.end.line, line);
+			assert.strictEqual(variable.range.start.character, startChar);
+			assert.strictEqual(variable.variableName, name);
+			assert.strictEqual(variable.range.end.character, name.length + startChar);
+		}
+	});
+
+	test('Special character variables in scriptblock', async () => {
+		const doc = await vscode.workspace.openTextDocument({
+			language: 'powershell',
+			content: `$sb = {\${hello \`{ \`} world}}`,
+		});
+
+		const provider = new PowerShellVariableInlineValuesProvider();
+
+		const result = await provider.provideInlineValues(doc, new vscode.Range(0, 0, 0, 0), {
+			stoppedLocation: new vscode.Range(doc.lineCount - 1, 0, doc.lineCount - 1, 0),
+			frameId: 0
+		});
+
+		assert.strictEqual(result?.length, 2);
+		for (let i = 0; i < result.length; i++) {
+			const variable = result![i] as vscode.InlineValueVariableLookup;
+
+			let name: string = '';
+			let startChar: number = 0;
+			let line: number = i;
+			switch (i) {
+				case 0:
+					name = '$sb';
+					break;
+				case 1:
+					name = '$hello { } world';
+					startChar = 7;
+					line = 0;
+					break;
+			}
+		
+			assert.strictEqual(variable.caseSensitiveLookup, false);
+			assert.strictEqual(variable.range.start.line, line);
+			assert.strictEqual(variable.range.end.line, line);
+			assert.strictEqual(variable.range.start.character, startChar);
+			assert.strictEqual(variable.variableName, name);
+			assert.strictEqual(variable.range.end.character, name.length + startChar);
+		}
+	});
+
+	test('Variables used with collections', async () => {
+		const doc = await vscode.workspace.openTextDocument({
+			language: 'powershell',
+			content: `
+$dict[$key]
+@($element,$element2, $element3)
+$normal, \${braces}, $script:scoped
+@{key = $var}
+@{key = \${special var}}
+`,
+		});
+
+		const provider = new PowerShellVariableInlineValuesProvider();
+
+		const result = await provider.provideInlineValues(doc, new vscode.Range(0, 0, 0, 0), {
+			stoppedLocation: new vscode.Range(doc.lineCount - 1, 0, doc.lineCount - 1, 0),
+			frameId: 0
+		});
+
+		assert.strictEqual(result?.length, 10);
+		for (let i = 0; i < result.length; i++) {
+			const variable = result![i] as vscode.InlineValueVariableLookup;
+
+			let name: string = '';
+			let startChar: number = 0;
+			let line: number = i+1;
+			switch (i) {
+				case 0:
+					name = '$dict';
+					break;
+				case 1:
+					name = '$key';
+					startChar = 6;
+					line = 1;
+					break;
+				case 2:
+					name = '$element';
+					startChar = 2;
+					line = 2;
+					break;
+				case 3:
+					name = '$element2';
+					startChar = 11;
+					line = 2;
+					break;
+				case 4:
+					name = '$element3';
+					startChar = 22;
+					line = 2;
+					break;
+				case 5:
+					name = '$normal';
+					line = 3;
+					break;
+				case 6:
 					name = '$braces';
 					startChar = 9;
-					line = 6;
+					line = 3;
 					break;
-				case 8:
+				case 7:
 					name = '$scoped';
 					startChar = 20;
+					line = 3;
+					break;
+				case 8:
+					name = '$var';
+					startChar = 8;
+					line = 4;
+					break;
+				case 9:
+					name = '$special var';
+					startChar = 8;
+					line = 5;
+					break;
+			}
+		
+			assert.strictEqual(variable.caseSensitiveLookup, false);
+			assert.strictEqual(variable.range.start.line, line);
+			assert.strictEqual(variable.range.end.line, line);
+			assert.strictEqual(variable.range.start.character, startChar);
+			assert.strictEqual(variable.variableName, name);
+			assert.strictEqual(variable.range.end.character, name.length + startChar);
+		}
+	});
+
+	test('Variables with modifiers', async () => {
+		const doc = await vscode.workspace.openTextDocument({
+			language: 'powershell',
+			content: `
+$a;
+$a,$b
+$a-$b
+$a+$b
+$a/$b
+$a*$b
+`,
+		});
+
+		const provider = new PowerShellVariableInlineValuesProvider();
+
+		const result = await provider.provideInlineValues(doc, new vscode.Range(0, 0, 0, 0), {
+			stoppedLocation: new vscode.Range(doc.lineCount - 1, 0, doc.lineCount - 1, 0),
+			frameId: 0
+		});
+
+		assert.strictEqual(result?.length, 11);
+		for (let i = 0; i < result.length; i++) {
+			const variable = result![i] as vscode.InlineValueVariableLookup;
+
+			let name: string = '';
+			let startChar: number = 0;
+			let line: number = i+1;
+			switch (i) {
+				case 0:
+					name = '$a';
+					break;
+				case 1:
+					name = '$a';
+					break;
+				case 2:
+					name = '$b';
+					startChar = 3;
+					line = 2;
+					break;
+				case 3:
+					name = '$a';
+					line = 3;
+					break;
+				case 4:
+					name = '$b';
+					startChar = 3;
+					line = 3;
+					break;
+				case 5:
+					name = '$a';
+					line = 4;
+					break;
+				case 6:
+					name = '$b';
+					startChar = 3;
+					line = 4;
+					break;
+				case 7:
+					name = '$a';
+					line = 5;
+					break;
+				case 8:
+					name = '$b';
+					startChar = 3;
+					line = 5;
+					break;
+				case 9:
+					name = '$a';
+					line = 6;
+					break;
+				case 10:
+					name = '$b';
+					startChar = 3;
 					line = 6;
 					break;
 			}
@@ -77,4 +450,4 @@ $true
 			assert.strictEqual(variable.range.end.character, name.length + startChar);
 		}
 	});
-});
+});
\ No newline at end of file

From ea75117d01bd47f9ff02539de5d67052482a3db9 Mon Sep 17 00:00:00 2001
From: Frode Flaten <3436158+fflaten@users.noreply.github.com>
Date: Fri, 3 Jun 2022 21:12:57 +0000
Subject: [PATCH 3/7] ignore invalid variable scopes

---
 src/powerShellVariableInlineValuesProvider.ts | 13 ++++++++++---
 src/test/suite/extension.test.ts              | 15 ++++++++++++++-
 2 files changed, 24 insertions(+), 4 deletions(-)

diff --git a/src/powerShellVariableInlineValuesProvider.ts b/src/powerShellVariableInlineValuesProvider.ts
index 51786f9..fe2ed39 100644
--- a/src/powerShellVariableInlineValuesProvider.ts
+++ b/src/powerShellVariableInlineValuesProvider.ts
@@ -3,14 +3,15 @@ import * as vscode from 'vscode';
 export class PowerShellVariableInlineValuesProvider implements vscode.InlineValuesProvider {
 
     // Known constants
-    private readonly ignoredVariables = /^\$(?:true|false|null)$/i;
+    private readonly knownConstants = /^\$(?:true|false|null)$/i;
+    private readonly validScopes = /^(?:global|local|script|using)$/i;
     
     // Variable patterns
     // https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_variables?view=powershell-5.1#variable-names-that-include-special-characters
     private readonly alphanumChars = /(?:\p{Lu}|\p{Ll}|\p{Lt}|\p{Lm}|\p{Lo}|\p{Nd}|[_?])/.source;
     private readonly variableRegex = new RegExp([
         '(?:\\$\\{(.*?)(?<!`)\\})' // Special characters variables. Lazy match until unescaped }
-        ,`|(?:\\$${this.alphanumChars}+:${this.alphanumChars}+)` // Scoped variables
+        ,`|(?:\\$\\w+:${this.alphanumChars}+)` // Scoped variables
         ,`|(?:\\$${this.alphanumChars}+)` // Normal variables
     ].join(''), 'giu'); // u flag to support unicode char classes
 
@@ -34,11 +35,17 @@ export class PowerShellVariableInlineValuesProvider implements vscode.InlineValu
                 // If there's a scope, we need to remove it
                 const colon = varName.indexOf(':');
                 if (colon !== -1) {
+                    // If invalid scope, ignore
+                    const scope = varName.substring(1, colon);
+                    if(!this.validScopes.test(scope)) {
+                        continue;
+                    }
+
                     varName = '$' + varName.substring(colon + 1);
                 }
 
                 // If known PowerShell constant, ignore
-                if (this.ignoredVariables.test(varName)) {
+                if (this.knownConstants.test(varName)) {
                     continue;
                 }
 
diff --git a/src/test/suite/extension.test.ts b/src/test/suite/extension.test.ts
index f255198..5bb876e 100644
--- a/src/test/suite/extension.test.ts
+++ b/src/test/suite/extension.test.ts
@@ -150,7 +150,11 @@ $something_wrong? = 123
 			language: 'powershell',
 			content: `
 $script:scoped = 5
+$global:scoped = 5
+$local:scoped = 5
+$using:scoped = 5
 \${Script:special scoped}
+$invalidscope:notdetected = 123
 4
 `,
 		});
@@ -162,7 +166,7 @@ $script:scoped = 5
 			frameId: 0
 		});
 
-		assert.strictEqual(result?.length, 2);
+		assert.strictEqual(result?.length, 5);
 		for (let i = 0; i < result.length; i++) {
 			const variable = result![i] as vscode.InlineValueVariableLookup;
 
@@ -174,6 +178,15 @@ $script:scoped = 5
 					name = '$scoped';
 					break;
 				case 1:
+					name = '$scoped';
+					break;
+				case 2:
+					name = '$scoped';
+					break;
+				case 3:
+					name = '$scoped';
+					break;
+				case 4:
 					name = '$special scoped';
 					break;
 			}

From 76151326656fa1925050ed2181e66cfb34fbe2c5 Mon Sep 17 00:00:00 2001
From: Frode Flaten <3436158+fflaten@users.noreply.github.com>
Date: Sat, 4 Jun 2022 10:18:32 +0000
Subject: [PATCH 4/7] cleanup variable regex

---
 src/powerShellVariableInlineValuesProvider.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/powerShellVariableInlineValuesProvider.ts b/src/powerShellVariableInlineValuesProvider.ts
index fe2ed39..5d33521 100644
--- a/src/powerShellVariableInlineValuesProvider.ts
+++ b/src/powerShellVariableInlineValuesProvider.ts
@@ -10,10 +10,10 @@ export class PowerShellVariableInlineValuesProvider implements vscode.InlineValu
     // https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_variables?view=powershell-5.1#variable-names-that-include-special-characters
     private readonly alphanumChars = /(?:\p{Lu}|\p{Ll}|\p{Lt}|\p{Lm}|\p{Lo}|\p{Nd}|[_?])/.source;
     private readonly variableRegex = new RegExp([
-        '(?:\\$\\{(.*?)(?<!`)\\})' // Special characters variables. Lazy match until unescaped }
-        ,`|(?:\\$\\w+:${this.alphanumChars}+)` // Scoped variables
-        ,`|(?:\\$${this.alphanumChars}+)` // Normal variables
-    ].join(''), 'giu'); // u flag to support unicode char classes
+        '(?:\\$\\{(.*?)(?<!`)\\})', // Special characters variables. Lazy match until unescaped }
+        `(?:\\$\\w+:${this.alphanumChars}+)`, // Scoped variables
+        `(?:\\$${this.alphanumChars}+)`, // Normal variables
+    ].join('|'), 'giu'); // u flag to support unicode char classes
 
     provideInlineValues(document: vscode.TextDocument, viewport: vscode.Range, context: vscode.InlineValueContext) : vscode.ProviderResult<vscode.InlineValue[]> {
         const allValues: vscode.InlineValue[] = [];

From 4a132ac3770800b494b87cd3f42794b006009cc6 Mon Sep 17 00:00:00 2001
From: Frode Flaten <3436158+fflaten@users.noreply.github.com>
Date: Sat, 4 Jun 2022 10:45:56 +0000
Subject: [PATCH 5/7] use named group and check for undefined

---
 src/powerShellVariableInlineValuesProvider.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/powerShellVariableInlineValuesProvider.ts b/src/powerShellVariableInlineValuesProvider.ts
index 5d33521..be80a12 100644
--- a/src/powerShellVariableInlineValuesProvider.ts
+++ b/src/powerShellVariableInlineValuesProvider.ts
@@ -10,7 +10,7 @@ export class PowerShellVariableInlineValuesProvider implements vscode.InlineValu
     // https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_variables?view=powershell-5.1#variable-names-that-include-special-characters
     private readonly alphanumChars = /(?:\p{Lu}|\p{Ll}|\p{Lt}|\p{Lm}|\p{Lo}|\p{Nd}|[_?])/.source;
     private readonly variableRegex = new RegExp([
-        '(?:\\$\\{(.*?)(?<!`)\\})', // Special characters variables. Lazy match until unescaped }
+        '(?:\\$\\{(?<specialName>.*?)(?<!`)\\})', // Special characters variables. Lazy match until unescaped }
         `(?:\\$\\w+:${this.alphanumChars}+)`, // Scoped variables
         `(?:\\$${this.alphanumChars}+)`, // Normal variables
     ].join('|'), 'giu'); // u flag to support unicode char classes
@@ -27,9 +27,9 @@ export class PowerShellVariableInlineValuesProvider implements vscode.InlineValu
             }
 
             for (let match = this.variableRegex.exec(line.text); match; match = this.variableRegex.exec(line.text)) {
-                // If we're looking at special characters variable, use the variable name in capture group 1
+                // If we're looking at special characters variable, use the extracted variable name in capture group
                 let varName = match[0][1] === '{'
-                    ? '$' + match[1].replace(/`(.)/g,'$1') // Remove backticks used as escape char for curly braces, unicode etc.
+                    ? '$' + match.groups?.specialName?.replace(/`(.)/g,'$1') // Remove backticks used as escape char for curly braces, unicode etc.
                     : match[0];
 
                 // If there's a scope, we need to remove it

From 959c6c69e60fe634f137145271e5a9bf0fafafac Mon Sep 17 00:00:00 2001
From: Frode Flaten <3436158+fflaten@users.noreply.github.com>
Date: Tue, 7 Jun 2022 17:27:41 +0000
Subject: [PATCH 6/7] add private and variable scope

---
 src/powerShellVariableInlineValuesProvider.ts |  8 +++++---
 src/test/suite/extension.test.ts              | 10 +++++++++-
 2 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/src/powerShellVariableInlineValuesProvider.ts b/src/powerShellVariableInlineValuesProvider.ts
index be80a12..9904eb2 100644
--- a/src/powerShellVariableInlineValuesProvider.ts
+++ b/src/powerShellVariableInlineValuesProvider.ts
@@ -4,8 +4,10 @@ export class PowerShellVariableInlineValuesProvider implements vscode.InlineValu
 
     // Known constants
     private readonly knownConstants = /^\$(?:true|false|null)$/i;
-    private readonly validScopes = /^(?:global|local|script|using)$/i;
-    
+
+    // https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_scopes?view=powershell-5.1#scope-modifiers
+    private readonly supportedScopes = /^(?:global|local|script|private|using|variable)$/i;
+
     // Variable patterns
     // https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_variables?view=powershell-5.1#variable-names-that-include-special-characters
     private readonly alphanumChars = /(?:\p{Lu}|\p{Ll}|\p{Lt}|\p{Lm}|\p{Lo}|\p{Nd}|[_?])/.source;
@@ -37,7 +39,7 @@ export class PowerShellVariableInlineValuesProvider implements vscode.InlineValu
                 if (colon !== -1) {
                     // If invalid scope, ignore
                     const scope = varName.substring(1, colon);
-                    if(!this.validScopes.test(scope)) {
+                    if(!this.supportedScopes.test(scope)) {
                         continue;
                     }
 
diff --git a/src/test/suite/extension.test.ts b/src/test/suite/extension.test.ts
index 5bb876e..9ae229d 100644
--- a/src/test/suite/extension.test.ts
+++ b/src/test/suite/extension.test.ts
@@ -153,6 +153,8 @@ $script:scoped = 5
 $global:scoped = 5
 $local:scoped = 5
 $using:scoped = 5
+$private:scoped = 5
+$variable:scoped = 5
 \${Script:special scoped}
 $invalidscope:notdetected = 123
 4
@@ -166,7 +168,7 @@ $invalidscope:notdetected = 123
 			frameId: 0
 		});
 
-		assert.strictEqual(result?.length, 5);
+		assert.strictEqual(result?.length, 7);
 		for (let i = 0; i < result.length; i++) {
 			const variable = result![i] as vscode.InlineValueVariableLookup;
 
@@ -187,6 +189,12 @@ $invalidscope:notdetected = 123
 					name = '$scoped';
 					break;
 				case 4:
+					name = '$scoped';
+					break;
+				case 5:
+					name = '$scoped';
+					break;
+				case 6:
 					name = '$special scoped';
 					break;
 			}

From f128cbc50b19480ca90c4645378a90236b95f2d5 Mon Sep 17 00:00:00 2001
From: Frode Flaten <3436158+fflaten@users.noreply.github.com>
Date: Tue, 7 Jun 2022 17:31:57 +0000
Subject: [PATCH 7/7] cleanup formatting

---
 .devcontainer/devcontainer.json               |  6 ++--
 .vscode/settings.json                         |  6 ++--
 .yarnrc                                       |  2 +-
 package.json                                  |  2 +-
 src/extension.ts                              |  2 +-
 src/powerShellVariableInlineValuesProvider.ts |  6 ++--
 src/test/suite/extension.test.ts              | 30 +++++++++----------
 7 files changed, 28 insertions(+), 26 deletions(-)

diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
index 4eb17d5..62dfb92 100644
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -5,13 +5,13 @@
 	"build": {
 		"dockerfile": "Dockerfile",
 		// Update 'VARIANT' to pick a Node version: 10, 12, 14
-		"args": { 
+		"args": {
 			"VARIANT": "14"
 		}
 	},
 
 	// Set *default* container specific settings.json values on container create.
-	"settings": { 
+	"settings": {
 		"terminal.integrated.shell.linux": "/bin/bash"
 	},
 
@@ -29,4 +29,4 @@
 
 	// Comment out connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
 	"remoteUser": "node"
-}
\ No newline at end of file
+}
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 30bf8c2..9b1ad57 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -7,5 +7,7 @@
         "out": true // set this to false to include "out" folder in search results
     },
     // Turn off tsc task auto detection since we have the necessary tasks as npm scripts
-    "typescript.tsc.autoDetect": "off"
-}
\ No newline at end of file
+    "typescript.tsc.autoDetect": "off",
+    "files.trimTrailingWhitespace": true,
+    "files.insertFinalNewline": true
+}
diff --git a/.yarnrc b/.yarnrc
index f757a6a..4f14322 100644
--- a/.yarnrc
+++ b/.yarnrc
@@ -1 +1 @@
---ignore-engines true
\ No newline at end of file
+--ignore-engines true
diff --git a/package.json b/package.json
index a84e354..135f4c2 100644
--- a/package.json
+++ b/package.json
@@ -43,4 +43,4 @@
 		"vscode-test": "^1.5.0",
 		"vsce": "^1.87.1"
 	}
-}
\ No newline at end of file
+}
diff --git a/src/extension.ts b/src/extension.ts
index 24c9522..d7b4892 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -5,4 +5,4 @@ export function activate(context: vscode.ExtensionContext) {
 	context.subscriptions.push(vscode.languages.registerInlineValuesProvider('powershell', new PowerShellVariableInlineValuesProvider()));
 }
 
-export function deactivate() {}
+export function deactivate() { }
diff --git a/src/powerShellVariableInlineValuesProvider.ts b/src/powerShellVariableInlineValuesProvider.ts
index 9904eb2..7602623 100644
--- a/src/powerShellVariableInlineValuesProvider.ts
+++ b/src/powerShellVariableInlineValuesProvider.ts
@@ -17,7 +17,7 @@ export class PowerShellVariableInlineValuesProvider implements vscode.InlineValu
         `(?:\\$${this.alphanumChars}+)`, // Normal variables
     ].join('|'), 'giu'); // u flag to support unicode char classes
 
-    provideInlineValues(document: vscode.TextDocument, viewport: vscode.Range, context: vscode.InlineValueContext) : vscode.ProviderResult<vscode.InlineValue[]> {
+    provideInlineValues(document: vscode.TextDocument, viewport: vscode.Range, context: vscode.InlineValueContext): vscode.ProviderResult<vscode.InlineValue[]> {
         const allValues: vscode.InlineValue[] = [];
 
         for (let l = 0; l <= context.stoppedLocation.end.line; l++) {
@@ -31,7 +31,7 @@ export class PowerShellVariableInlineValuesProvider implements vscode.InlineValu
             for (let match = this.variableRegex.exec(line.text); match; match = this.variableRegex.exec(line.text)) {
                 // If we're looking at special characters variable, use the extracted variable name in capture group
                 let varName = match[0][1] === '{'
-                    ? '$' + match.groups?.specialName?.replace(/`(.)/g,'$1') // Remove backticks used as escape char for curly braces, unicode etc.
+                    ? '$' + match.groups?.specialName?.replace(/`(.)/g, '$1') // Remove backticks used as escape char for curly braces, unicode etc.
                     : match[0];
 
                 // If there's a scope, we need to remove it
@@ -39,7 +39,7 @@ export class PowerShellVariableInlineValuesProvider implements vscode.InlineValu
                 if (colon !== -1) {
                     // If invalid scope, ignore
                     const scope = varName.substring(1, colon);
-                    if(!this.supportedScopes.test(scope)) {
+                    if (!this.supportedScopes.test(scope)) {
                         continue;
                     }
 
diff --git a/src/test/suite/extension.test.ts b/src/test/suite/extension.test.ts
index 9ae229d..3eb485d 100644
--- a/src/test/suite/extension.test.ts
+++ b/src/test/suite/extension.test.ts
@@ -32,7 +32,7 @@ $normal, \${braces}, $script:scoped
 
 			let name: string = '';
 			let startChar: number = 0;
-			let line: number = i+1;
+			let line: number = i + 1;
 			switch (i) {
 				case 0:
 					name = '$normal';
@@ -60,7 +60,7 @@ $normal, \${braces}, $script:scoped
 					line = 5;
 					break;
 			}
-		
+
 			assert.strictEqual(variable.caseSensitiveLookup, false);
 			assert.strictEqual(variable.range.start.line, line);
 			assert.strictEqual(variable.range.end.line, line);
@@ -84,7 +84,7 @@ $normal, \${braces}, $script:scoped
 		});
 
 		assert.strictEqual(result?.length, 1);
-		
+
 		// Making sure the test actually ran by including a real variable
 		const variable = result![0] as vscode.InlineValueVariableLookup;
 		assert.strictEqual(variable.caseSensitiveLookup, false);
@@ -120,7 +120,7 @@ $something_wrong? = 123
 
 			let name: string = '';
 			let startChar: number = 0;
-			let line: number = i+1;
+			let line: number = i + 1;
 			switch (i) {
 				case 0:
 					name = '$normal';
@@ -135,7 +135,7 @@ $something_wrong? = 123
 					name = '$something_wrong?';
 					break;
 			}
-		
+
 			assert.strictEqual(variable.caseSensitiveLookup, false);
 			assert.strictEqual(variable.range.start.line, line);
 			assert.strictEqual(variable.range.end.line, line);
@@ -174,7 +174,7 @@ $invalidscope:notdetected = 123
 
 			let name: string = '';
 			let startChar: number = 0;
-			let line: number = i+1;
+			let line: number = i + 1;
 			switch (i) {
 				case 0:
 					name = '$scoped';
@@ -198,7 +198,7 @@ $invalidscope:notdetected = 123
 					name = '$special scoped';
 					break;
 			}
-		
+
 			assert.strictEqual(variable.caseSensitiveLookup, false);
 			assert.strictEqual(variable.range.start.line, line);
 			assert.strictEqual(variable.range.end.line, line);
@@ -233,7 +233,7 @@ $invalidscope:notdetected = 123
 
 			let name: string = '';
 			let startChar: number = 0;
-			let line: number = i+1;
+			let line: number = i + 1;
 			switch (i) {
 				case 0:
 					name = '$hello`b';
@@ -251,7 +251,7 @@ $invalidscope:notdetected = 123
 					name = '$bra%!c\\e}<s';
 					break;
 			}
-		
+
 			assert.strictEqual(variable.caseSensitiveLookup, false);
 			assert.strictEqual(variable.range.start.line, line);
 			assert.strictEqual(variable.range.end.line, line);
@@ -291,7 +291,7 @@ $invalidscope:notdetected = 123
 					line = 0;
 					break;
 			}
-		
+
 			assert.strictEqual(variable.caseSensitiveLookup, false);
 			assert.strictEqual(variable.range.start.line, line);
 			assert.strictEqual(variable.range.end.line, line);
@@ -326,7 +326,7 @@ $normal, \${braces}, $script:scoped
 
 			let name: string = '';
 			let startChar: number = 0;
-			let line: number = i+1;
+			let line: number = i + 1;
 			switch (i) {
 				case 0:
 					name = '$dict';
@@ -376,7 +376,7 @@ $normal, \${braces}, $script:scoped
 					line = 5;
 					break;
 			}
-		
+
 			assert.strictEqual(variable.caseSensitiveLookup, false);
 			assert.strictEqual(variable.range.start.line, line);
 			assert.strictEqual(variable.range.end.line, line);
@@ -412,7 +412,7 @@ $a*$b
 
 			let name: string = '';
 			let startChar: number = 0;
-			let line: number = i+1;
+			let line: number = i + 1;
 			switch (i) {
 				case 0:
 					name = '$a';
@@ -462,7 +462,7 @@ $a*$b
 					line = 6;
 					break;
 			}
-		
+
 			assert.strictEqual(variable.caseSensitiveLookup, false);
 			assert.strictEqual(variable.range.start.line, line);
 			assert.strictEqual(variable.range.end.line, line);
@@ -471,4 +471,4 @@ $a*$b
 			assert.strictEqual(variable.range.end.character, name.length + startChar);
 		}
 	});
-});
\ No newline at end of file
+});