fix(package): keep Swift regex literals out of the comment scanner

`#/foo//bar/#` is a valid extended regex literal with no comment in it, but the
scanner only knew the `#"` raw-string family, so it read the literal's `//` as a
line comment and shipped `let pattern = #/foo` — Swift that does not compile.
Add `#/…/#` and `##/…/##` as a literal context: matching `#` counts, the
single- and multi-line forms, Swift's own-line rule for a multi-line closing
delimiter, and the `\/` escape that keeps one from closing early.

Bare `/…/` literals stay unresolvable, because the same `/` opens a comment,
divides, and starts a regex literal, and only the parse separates them. Where
one could begin — an expression position whose `/` is not followed by a space,
a tab or `)` — packaging throws by file and line instead of rewriting bytes it
cannot prove are code. Divisions (`width/2`, `Double(3)/Double(4)`), the
recording scripts' shebang and `(/)` keep flowing through.

Author: thymikee

scripts/__tests__/strip-swift-comments.test.ts

@@ -112,6 +112,81 @@ test('preserves a multi-line raw literal and its line continuations', () => {
   assert.equal(strip(source), source);
 });
 
+// Every Swift snippet in the regex-literal tests below parses clean under `xcrun swiftc -parse`
+// (Swift 6.2), and so does what the scanner leaves of it. `#/foo//bar/#` has no comment in it at
+// all: before the scanner knew the delimiter, it shipped `let pattern = #/foo`.
+test('preserves extended regex literals whose contents are comment-shaped', () => {
+  const source = swift(
+    'let pattern = #/foo//bar/#',
+    'let pounded = ##/a//b/#c/##',
+    'let blockish = #/x/*y/#',
+    String.raw`let escaped = #/a\/#b/#`,
+  );
+
+  assert.equal(strip(source), source);
+  assert.equal(stripSwiftComments(source).removedComments, 0);
+});
+
+test('strips a real comment that trails an extended regex literal', () => {
+  const source = swift(
+    'let trailing = #/a//b/#  // trailing',
+    'let blocked = ##/c/*d*/##  /* block */',
+    'let next = 1',
+  );
+
+  assert.equal(
+    strip(source),
+    swift('let trailing = #/a//b/#', 'let blocked = ##/c/*d*/##', 'let next = 1'),
+  );
+  assert.equal(stripSwiftComments(source).removedComments, 2);
+});
+
+test('preserves a multi-line extended regex literal verbatim, comment-shaped lines included', () => {
+  const source = swift(
+    'let multi = #/',
+    '  foo//bar',
+    '  /*e*/',
+    String.raw`  a\/#b`,
+    '',
+    '  /#',
+    'let after = 1  // note',
+  );
+
+  assert.equal(
+    strip(source),
+    swift(
+      'let multi = #/',
+      '  foo//bar',
+      '  /*e*/',
+      String.raw`  a\/#b`,
+      '',
+      '  /#',
+      'let after = 1',
+    ),
+  );
+});
+
+test('reads an unspaced division as an operator, not as a bare regex literal', () => {
+  const source = swift(
+    '#!/usr/bin/env swift',
+    'let half = width/2  // note',
+    'let ratio = Double(3)/Double(4)',
+    'let spaced = width / 2  // also fine',
+    'let divide: (Int, Int) -> Int = (/)',
+  );
+
+  assert.equal(
+    strip(source),
+    swift(
+      '#!/usr/bin/env swift',
+      'let half = width/2',
+      'let ratio = Double(3)/Double(4)',
+      'let spaced = width / 2',
+      'let divide: (Int, Int) -> Int = (/)',
+    ),
+  );
+});
+
 test('reads interpolation segments as code without losing their nested literals', () => {
   const source = swift(
     String.raw`let line = "prefix \(makeURL("https://example.com")) suffix" // trailing`,
@@ -231,3 +306,35 @@ test('throws when an interpolation segment never closes', () => {
     /Unterminated interpolation in Fixture\.swift/,
   );
 });
+
+// A bare `/…/` is the one construct a scanner cannot resolve: Swift lexes a comment, a division
+// and a regex literal from the same `/`, and only the parse tells them apart. Packaging fails
+// rather than rewrite bytes it cannot prove are code.
+test('throws on a bare regex literal instead of reading its contents as a comment', () => {
+  assert.throws(
+    () => strip(swift('let a = 1', 'let pattern = /foo//bar/')),
+    /Ambiguous bare regex literal or division in Fixture\.swift:2/,
+  );
+  assert.throws(
+    () => strip(swift('func f() -> Regex<Substring> {', String.raw`  return /x\/y/`, '}')),
+    /Ambiguous bare regex literal or division in Fixture\.swift:2/,
+  );
+});
+
+test('throws on an unterminated extended regex literal', () => {
+  assert.throws(
+    () => strip(swift('let a = 1', 'let pattern = #/no closing', 'let b = 2 // note')),
+    /Unterminated regex literal in Fixture\.swift:2/,
+  );
+  assert.throws(
+    () => strip(swift('let a = 1', 'let pattern = #/', '  never closed')),
+    /Unterminated regex literal in Fixture\.swift \(started at line 2\)/,
+  );
+});
+
+test('throws when a multi-line regex literal closes mid-line', () => {
+  assert.throws(
+    () => strip(swift('let multi = #/', '  mid/#line stays', '  /#')),
+    /Multi-line regex literal in Fixture\.swift:1 closes mid-line at line 2/,
+  );
+});