shellIntegrationAddon: fix incorrect deserializeMessage implementation

The original implementation confused escaped and un-escaped sequences
due to squashing each adjacent pair of backslashes prior to parsing.

Unlike encoding, decoding cannot be performed in passes this way: it
must be sequential, because of the potential for overlapping patterns
(e.g. the third backslash in "\\\x3b").

This replaces the implementation with a single sequential regex, which
matches the escape sequences and replaces each match. This enables the
tests that were broken in the previous implementation.

To illustrate, given the following two different original values (here
as literals between «», without any escaping):
  a. «Packing\Stuff\x3BEarmuffs»
  b. «Packing\Stuff;Earmuffs»

Those should be distinctly encoded as:
  a. «Packing\\Stuff\\x3BEarmuffs»
  b. «Packing\\Stuff\x3BEarmuffs»

The original implementation wrongly threw away the escaping information
by replacing each adjacent pairs of backslashes with a single backslash,
regardless of whether escaping was in effect or not:
  a. «Packing\Stuff\x3BEarmuffs»
  b. «Packing\Stuff\x3BEarmuffs»

The new implementation matches, in (a), each "\\"; and there are no
non-overlapping "\x…" sequences. In (b), the first "\\" is matches, and
the "\x3B" is matched.

This works for any correct combination of adjacent escape squences.

Author: rwe

src/vs/platform/terminal/common/xterm/shellIntegrationAddon.ts

@@ -513,16 +513,12 @@ export class ShellIntegrationAddon extends Disposable implements IShellIntegrati
 }
 
 export function deserializeMessage(message: string): string {
-	let result = message.replace(/\\\\/g, '\\');
-	const deserializeRegex = /\\x([0-9a-f]{2})/i;
-	while (true) {
-		const match = result.match(deserializeRegex);
-		if (match?.index == null || match.length < 2) {
-			break;
-		}
-		result = result.slice(0, match.index) + String.fromCharCode(parseInt(match[1], 16)) + result.slice(match.index + 4);
-	}
-	return result;
+	return message.replaceAll(
+		// Backslash ('\') followed by an escape operator: either another '\', or 'x' and two hex chars.
+		/\\(\\|x([0-9a-f]{2}))/gi,
+		// If it's a hex value, parse it to a character.
+		// Otherwise the operator is '\', which we return literally, now unescaped.
+		(_match: string, op: string, hex?: string) => hex ? String.fromCharCode(parseInt(hex, 16)) : op);
 }
 
 export function parseKeyValueAssignment(message: string): { key: string; value: string | undefined } {

src/vs/workbench/contrib/terminal/test/browser/xterm/shellIntegrationAddon.test.ts

@@ -287,20 +287,8 @@ suite('deserializeMessage', () => {
 		['non-initial escaped backslash followed by literal "x0a" is not a newline', `foo${Backslash}${Backslash}x0a`, `foo${Backslash}x0a`],
 	];
 
-	const BROKEN: readonly string[] = [
-		'escaped backslash followed by literal "x3b" is not a semicolon',
-		'non-initial escaped backslash followed by literal "x3b" is not a semicolon',
-		'escaped backslash followed by literal "x0a" is not a newline',
-		'non-initial escaped backslash followed by literal "x0a" is not a newline',
-	];
-
 	cases.forEach(([title, input, expected]) => {
-		const fn = () => strictEqual(deserializeMessage(input), expected);
-		if (BROKEN.includes(title)) {
-			test.skip(title, fn);
-		} else {
-			test(title, fn);
-		}
+		test(title, () => strictEqual(deserializeMessage(input), expected));
 	});
 });