Treat hash suffixes as inline expectation notes

Recognize # as a trailing-note delimiter alongside // so learning preserves annotations such as # NOT OK instead of rendering their words as expectation tags. Rewrite the Ruby tests that used repeated # $ delimiters to use unambiguous $ continuations.

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

Copilot-Session: 1adfa307-c48e-43f5-94e3-8286e4a8c083

Author: d10c

ruby/ql/test/library-tests/dataflow/array-flow/array_flow.rb

@@ -371,24 +371,24 @@ def m41
 def m42(i)
     a = [0, 1, source(42.1), source(42.2)]
     b = a.drop(i)
-    sink(b[0]) # $ hasValueFlow=42.1 # $ hasValueFlow=42.2
+    sink(b[0]) # $ hasValueFlow=42.1 hasValueFlow=42.2
     b = a.drop(1)
     sink(b[0])
     sink(b[1]) # $ hasValueFlow=42.1
-    sink(b[i]) # $ hasValueFlow=42.1 # $ hasValueFlow=42.2
+    sink(b[i]) # $ hasValueFlow=42.1 hasValueFlow=42.2
     a[i] = source(42.3)
     b = a.drop(1)
-    sink(b[1]) # $ hasValueFlow=42.1 # $ hasValueFlow=42.3
+    sink(b[1]) # $ hasValueFlow=42.1 hasValueFlow=42.3
     c = b.drop(100)
     sink(c[1]) # $ hasValueFlow=42.3
 end
 
 def m43
     a = [0, 1, source(43.1), source(43.2)]
     b = a.drop_while do |x|
-        sink x # $ hasValueFlow=43.1 # $ hasValueFlow=43.2
+        sink x # $ hasValueFlow=43.1 hasValueFlow=43.2
     end
-    sink(b[0]) # $ hasValueFlow=43.1 # $ hasValueFlow=43.2
+    sink(b[0]) # $ hasValueFlow=43.1 hasValueFlow=43.2
 end
 
 def m44
@@ -1464,7 +1464,7 @@ def m121(i)
     sink(b[i]) # $ hasValueFlow=121.1 $ hasValueFlow=121.2
     a[i] = source(121.3)
     b = a.take(3)
-    sink(b[2]) # $ hasValueFlow=121.1 # $ hasValueFlow=121.3
+    sink(b[2]) # $ hasValueFlow=121.1 hasValueFlow=121.3
 end
 
 def m122

ruby/ql/test/library-tests/dataflow/call-sensitivity/call_sensitivity.rb

@@ -68,7 +68,7 @@ def call_method3 x
   end
 
   def self.singleton_method1 x
-    sink x # $ hasValueFlow=14 $ hasValueFlow=15 # $ hasValueFlow=16 $ hasValueFlow=17
+    sink x # $ hasValueFlow=14 hasValueFlow=15 hasValueFlow=16 hasValueFlow=17
   end
 
   def method4(x, y)

ruby/ql/test/library-tests/dataflow/hash-flow/hash_flow.rb

@@ -715,7 +715,7 @@ def m43()
         :c => taint(43.2)
     }
     a = hash.values
-    sink (a[0]) # $ hasValueFlow=43.1 # $ hasValueFlow=43.2
+    sink (a[0]) # $ hasValueFlow=43.1 hasValueFlow=43.2
 end
 
 m43()

shared/util/codeql/util/test/InlineExpectationsTest.qll

@@ -524,7 +524,7 @@ module Make<InlineExpectationsTestSig Impl> {
  * is treated as part of the expected results, except that the comment may contain a `//` or `#`
  * sequence to treat the remainder of the line as a regular (non-interpreted) comment.
  */
-private string expectationCommentPattern() { result = "\\s*\\$ ((?:[^/]|/[^/])*)(?:(//|#).*)?" }
+private string expectationCommentPattern() { result = "\\s*\\$ ((?:[^/#]|/[^/])*)(?:(//|#).*)?" }
 
 /**
  * The possible columns in an expectation comment. The `TDefaultColumn` branch represents the first
@@ -1180,22 +1180,22 @@ module TestPostProcessing {
        * Holds if `comment` carries a trailing regular (non-interpreted) note `note`, with the note's
        * own comment marker and surrounding whitespace stripped. This is either:
        *
-       * - the text after a `//` that follows the expectations in an expectation comment (for example
-       *   `note` in `// $ Alert // note` or `# $ Alert // note`), which the framework treats as an
-       *   ordinary comment (see `expectationCommentPattern`); or
+       * - the text after a `//` or `#` that follows the expectations in an expectation comment (for
+       *   example `note` in `// $ Alert // note`, `# $ Alert // note`, or
+       *   `# $ Alert # note`), which the framework treats as an ordinary comment (see
+       *   `expectationCommentPattern`); or
        * - the whole content of a plain comment that carries no expectation at all (for example `note`
        *   in `// note` or `# note`), into which `--learn` may merge a freshly learned tag.
        *
        * `codeql test run --learn` keeps this note when it rewrites, deletes, or merges into the
        * comment, re-wrapping it with the appropriate markers (`<marker> $ ... // note` when
        * expectations remain, or `<marker> note` when none do), so an explanatory note written next to
-       * code is never lost. Only `//` delimits such a note within an expectation comment, mirroring
-       * `expectationCommentPattern`'s `(?:[^/]|/[^/])*` expectation region, which ends only at `//`; a
-       * `#` never does, so `# $ Alert # note` reads `note` as a tag rather than a note.
+       * code is never lost.
        */
       private string getTrailingNote(TestImpl2::ExpectationComment comment) {
         (
-          result = comment.getContents().regexpCapture("\\s*\\$ (?:[^/]|/[^/])*//(.*)", 1).trim()
+          result =
+            comment.getContents().regexpCapture("\\s*\\$ (?:[^/#]|/[^/])*(?://|#)(.*)", 1).trim()
           or
           // A plain comment with no expectation of its own: its whole content is the note.
           not hasExpectation(comment, _, _, _, _) and
@@ -1409,12 +1409,12 @@ module TestPostProcessing {
         exists(string body, string trailingSuffix |
           // Preserve a trailing regular note (e.g. the `note` in `// $ Alert // note`) that sits
           // after the expectations, so rewriting the expectations never drops an explanatory note.
-          // The inner delimiter is always `//`, which the framework recognises regardless of the
-          // outer comment marker (so a `#`-comment file renders `# $ Alert // note`).
+          // Use the file's line-comment marker for the inner delimiter, so a `#`-comment file renders
+          // `# $ Alert # note`.
           (
             exists(string note |
               note = getTrailingNote(comment) and
-              trailingSuffix = " // " + note
+              trailingSuffix = " " + Input::getStartCommentMarker(relativePath) + " " + note
             )
             or
             not exists(getTrailingNote(comment)) and trailingSuffix = ""