Widen escape round-trip test to all printable ASCII neighbours

The test claimed exhaustive coverage but checked seven suffix characters
and no prefix at all. Cover every printable ASCII neighbour on both
sides of each escape shape, rendering `"` and `\` as Rust would. 2280
cases, 24ms.

Also state the NUL case as the single literal `"\01"`, since the `+`
notation read as concatenation of two separate literals.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Author: redsun82

python/extractor/semmle/python/parser/tsg_parser.py

@@ -179,7 +179,8 @@ def read_tsg_python_output(path, logger):
 #    variation selector, U+200D zero width joiner and combining accents -- are rendered as `\u{...}`,
 #    a syntax Python does not know at all;
 #  - NUL is rendered as `\0`, which Python reads as the start of an *octal* escape, silently
-#    swallowing up to two more digits (`"\0" + "1"` would decode to `\x01`).
+#    swallowing up to two more digits (NUL followed by `1` is emitted as `"\01"`, which decodes
+#    to `\x01`).
 # Everything else Rust emits (`\t`, `\r`, `\n`, `\\`, `\"`, and unescaped characters) is read back
 # identically by `literal_eval`, as verified exhaustively over every Unicode scalar value.
 _RUST_ESCAPE = re.compile(r"\\(?:u\{([0-9a-fA-F]{1,6})\}|.)", re.DOTALL)

python/extractor/tests/test_tsg_parser.py

@@ -37,26 +37,34 @@ def test_nul_is_not_left_as_an_octal_escape(self):
         self.assertEqual(rust_to_python_escapes(r'"\01"'), r'"\x001"')
 
     def test_every_escape_shape_round_trips(self):
-        # Rust's `Debug for str` only ever emits these shapes. Checked exhaustively against every
-        # Unicode scalar value, each also paired with every printable ASCII neighbour.
-        for rendered, expected in [
-            (r'"\0"', "\x00"),
-            (r'"\t"', "\t"),
-            (r'"\n"', "\n"),
-            (r'"\r"', "\r"),
-            (r'"\\"', "\\"),
-            (r'"\""', '"'),
-            (r'"\u{1}"', "\u0001"),
-            (r'"\u{1f}"', "\u001f"),
-            (r'"\u{300}"', "\u0300"),
-            (r'"\u{fe0f}"', "\ufe0f"),
-            (r'"\u{e0100}"', "\U000e0100"),
-            (r'"\u{10fffe}"', "\U0010fffe"),
+        # Rust's `Debug for str` only ever emits these escape shapes. Check that each round-trips
+        # with every printable ASCII neighbour before and after it.
+        for escape_shape, expected in [
+            (r'\0', "\x00"),
+            (r'\t', "\t"),
+            (r'\n', "\n"),
+            (r'\r', "\r"),
+            (r'\\', "\\"),
+            (r'\"', '"'),
+            (r'\u{1}', "\u0001"),
+            (r'\u{1f}', "\u001f"),
+            (r'\u{300}', "\u0300"),
+            (r'\u{fe0f}', "\ufe0f"),
+            (r'\u{e0100}', "\U000e0100"),
+            (r'\u{10fffe}', "\U0010fffe"),
         ]:
-            for neighbour in ["", "0", "7", "9", "f", "u", "{"]:
-                with self.subTest(rendered=rendered, neighbour=neighbour):
-                    text = rendered[:-1] + neighbour + '"'
-                    self.assertEqual(literal_eval(rust_to_python_escapes(text)), expected + neighbour)
+            for neighbour in map(chr, range(0x20, 0x7F)):
+                rendered_neighbour = {"\\": r"\\", '"': r'\"'}.get(neighbour, neighbour)
+                for position, text, expected_value in [
+                    ("before", '"' + rendered_neighbour + escape_shape + '"', neighbour + expected),
+                    ("after", '"' + escape_shape + rendered_neighbour + '"', expected + neighbour),
+                ]:
+                    with self.subTest(
+                        escape_shape=escape_shape,
+                        neighbour=neighbour,
+                        position=position,
+                    ):
+                        self.assertEqual(literal_eval(rust_to_python_escapes(text)), expected_value)
 
     def test_evaluate_string_on_reported_value(self):
         # The exact value from https://github.com/github/codeql/issues/22435 that used to raise