From 7440eb4b11cd2da5283a8060bab0139c269a4195 Mon Sep 17 00:00:00 2001
From: Earlopain <14981592+Earlopain@users.noreply.github.com>
Date: Thu, 4 Dec 2025 11:58:51 +0100
Subject: [PATCH] Fix `%Q` with newline delimiter and heredoc interpolation

The lexer did not jump to the `heredoc_end`, causing the heredoc end delimiter
to be parsed twice.

Normally the heredocs get flushed when a newline is encountered. But because
the newline is part of the string delimiter, that codepath is not taken.

Fixes [Bug #21758]
---
 .../heredoc_percent_q_newline_delimiter.txt   | 114 ++++++++++++++++++
 src/prism.c                                   |   7 ++
 .../heredoc_percent_q_newline_delimiter.txt   |  11 ++
 .../heredoc_percent_q_newline_delimiter.txt   |  22 ++++
 test/prism/ruby/parser_test.rb                |   3 +
 test/prism/ruby/ruby_parser_test.rb           |   1 +
 6 files changed, 158 insertions(+)
 create mode 100644 snapshots/heredoc_percent_q_newline_delimiter.txt
 create mode 100644 test/prism/errors/heredoc_percent_q_newline_delimiter.txt
 create mode 100644 test/prism/fixtures/heredoc_percent_q_newline_delimiter.txt

diff --git a/snapshots/heredoc_percent_q_newline_delimiter.txt b/snapshots/heredoc_percent_q_newline_delimiter.txt
new file mode 100644
index 0000000000..75c436b670
--- /dev/null
+++ b/snapshots/heredoc_percent_q_newline_delimiter.txt
@@ -0,0 +1,114 @@
+@ ProgramNode (location: (1,0)-(22,0))
+├── flags: ∅
+├── locals: []
+└── statements:
+    @ StatementsNode (location: (1,0)-(22,0))
+    ├── flags: ∅
+    └── body: (length: 7)
+        ├── @ InterpolatedStringNode (location: (1,0)-(3,0))
+        │   ├── flags: newline, static_literal, mutable
+        │   ├── opening_loc: (1,0)-(2,0) = "%Q\n"
+        │   ├── parts: (length: 1)
+        │   │   └── @ EmbeddedStatementsNode (location: (2,0)-(2,6))
+        │   │       ├── flags: ∅
+        │   │       ├── opening_loc: (2,0)-(2,2) = "\#{"
+        │   │       ├── statements:
+        │   │       │   @ StatementsNode (location: (2,2)-(2,5))
+        │   │       │   ├── flags: ∅
+        │   │       │   └── body: (length: 1)
+        │   │       │       └── @ StringNode (location: (2,2)-(2,5))
+        │   │       │           ├── flags: static_literal, frozen
+        │   │       │           ├── opening_loc: (2,2)-(2,5) = "<<B"
+        │   │       │           ├── content_loc: (3,0)-(3,0) = ""
+        │   │       │           ├── closing_loc: (3,0)-(4,0) = "B\n"
+        │   │       │           └── unescaped: ""
+        │   │       └── closing_loc: (2,5)-(2,6) = "}"
+        │   └── closing_loc: (2,6)-(3,0) = "\n"
+        ├── @ InterpolatedStringNode (location: (5,0)-(7,0))
+        │   ├── flags: newline, static_literal, mutable
+        │   ├── opening_loc: (5,0)-(6,0) = "%\n"
+        │   ├── parts: (length: 1)
+        │   │   └── @ EmbeddedStatementsNode (location: (6,0)-(6,6))
+        │   │       ├── flags: ∅
+        │   │       ├── opening_loc: (6,0)-(6,2) = "\#{"
+        │   │       ├── statements:
+        │   │       │   @ StatementsNode (location: (6,2)-(6,5))
+        │   │       │   ├── flags: ∅
+        │   │       │   └── body: (length: 1)
+        │   │       │       └── @ StringNode (location: (6,2)-(6,5))
+        │   │       │           ├── flags: static_literal, frozen
+        │   │       │           ├── opening_loc: (6,2)-(6,5) = "<<B"
+        │   │       │           ├── content_loc: (7,0)-(7,0) = ""
+        │   │       │           ├── closing_loc: (7,0)-(8,0) = "B\n"
+        │   │       │           └── unescaped: ""
+        │   │       └── closing_loc: (6,5)-(6,6) = "}"
+        │   └── closing_loc: (6,6)-(7,0) = "\n"
+        ├── @ StringNode (location: (9,0)-(9,3))
+        │   ├── flags: newline
+        │   ├── opening_loc: (9,0)-(9,3) = "<<A"
+        │   ├── content_loc: (10,0)-(10,0) = ""
+        │   ├── closing_loc: (10,0)-(11,0) = "A\n"
+        │   └── unescaped: ""
+        ├── @ InterpolatedStringNode (location: (9,5)-(12,0))
+        │   ├── flags: newline, static_literal, mutable
+        │   ├── opening_loc: (9,5)-(10,0) = "%Q\n"
+        │   ├── parts: (length: 1)
+        │   │   └── @ EmbeddedStatementsNode (location: (11,0)-(11,6))
+        │   │       ├── flags: ∅
+        │   │       ├── opening_loc: (11,0)-(11,2) = "\#{"
+        │   │       ├── statements:
+        │   │       │   @ StatementsNode (location: (11,2)-(11,5))
+        │   │       │   ├── flags: ∅
+        │   │       │   └── body: (length: 1)
+        │   │       │       └── @ StringNode (location: (11,2)-(11,5))
+        │   │       │           ├── flags: static_literal, frozen
+        │   │       │           ├── opening_loc: (11,2)-(11,5) = "<<B"
+        │   │       │           ├── content_loc: (12,0)-(12,0) = ""
+        │   │       │           ├── closing_loc: (12,0)-(13,0) = "B\n"
+        │   │       │           └── unescaped: ""
+        │   │       └── closing_loc: (11,5)-(11,6) = "}"
+        │   └── closing_loc: (11,6)-(12,0) = "\n"
+        ├── @ StringNode (location: (14,0)-(14,3))
+        │   ├── flags: newline
+        │   ├── opening_loc: (14,0)-(14,3) = "<<A"
+        │   ├── content_loc: (15,0)-(15,0) = ""
+        │   ├── closing_loc: (15,0)-(16,0) = "A\n"
+        │   └── unescaped: ""
+        ├── @ InterpolatedStringNode (location: (14,5)-(17,0))
+        │   ├── flags: newline, static_literal, mutable
+        │   ├── opening_loc: (14,5)-(15,0) = "%\n"
+        │   ├── parts: (length: 1)
+        │   │   └── @ EmbeddedStatementsNode (location: (16,0)-(16,6))
+        │   │       ├── flags: ∅
+        │   │       ├── opening_loc: (16,0)-(16,2) = "\#{"
+        │   │       ├── statements:
+        │   │       │   @ StatementsNode (location: (16,2)-(16,5))
+        │   │       │   ├── flags: ∅
+        │   │       │   └── body: (length: 1)
+        │   │       │       └── @ StringNode (location: (16,2)-(16,5))
+        │   │       │           ├── flags: static_literal, frozen
+        │   │       │           ├── opening_loc: (16,2)-(16,5) = "<<B"
+        │   │       │           ├── content_loc: (17,0)-(17,0) = ""
+        │   │       │           ├── closing_loc: (17,0)-(18,0) = "B\n"
+        │   │       │           └── unescaped: ""
+        │   │       └── closing_loc: (16,5)-(16,6) = "}"
+        │   └── closing_loc: (16,6)-(17,0) = "\n"
+        └── @ InterpolatedStringNode (location: (20,0)-(22,0))
+            ├── flags: newline, static_literal, mutable
+            ├── opening_loc: (20,0)-(21,0) = "%Q\r\n"
+            ├── parts: (length: 1)
+            │   └── @ EmbeddedStatementsNode (location: (21,0)-(21,6))
+            │       ├── flags: ∅
+            │       ├── opening_loc: (21,0)-(21,2) = "\#{"
+            │       ├── statements:
+            │       │   @ StatementsNode (location: (21,2)-(21,5))
+            │       │   ├── flags: ∅
+            │       │   └── body: (length: 1)
+            │       │       └── @ StringNode (location: (21,2)-(21,5))
+            │       │           ├── flags: static_literal, frozen
+            │       │           ├── opening_loc: (21,2)-(21,5) = "<<B"
+            │       │           ├── content_loc: (22,0)-(22,0) = ""
+            │       │           ├── closing_loc: (22,0)-(23,0) = "B\n"
+            │       │           └── unescaped: ""
+            │       └── closing_loc: (21,5)-(21,6) = "}"
+            └── closing_loc: (21,6)-(22,0) = "\r\n"
diff --git a/src/prism.c b/src/prism.c
index 02247734e2..77ac74192e 100644
--- a/src/prism.c
+++ b/src/prism.c
@@ -11612,6 +11612,13 @@ parser_lex(pm_parser_t *parser) {
                         LEX(PM_TOKEN_LABEL_END);
                     }
 
+                    // When the delimiter itself is a newline, we won't
+                    // get a chance to flush heredocs in the usual places since
+                    // the newline is already consumed.
+                    if (term == '\n' && parser->heredoc_end) {
+                        parser_flush_heredoc_end(parser);
+                    }
+
                     lex_state_set(parser, PM_LEX_STATE_END);
                     lex_mode_pop(parser);
                     LEX(PM_TOKEN_STRING_END);
diff --git a/test/prism/errors/heredoc_percent_q_newline_delimiter.txt b/test/prism/errors/heredoc_percent_q_newline_delimiter.txt
new file mode 100644
index 0000000000..73664c071f
--- /dev/null
+++ b/test/prism/errors/heredoc_percent_q_newline_delimiter.txt
@@ -0,0 +1,11 @@
+%q
+#{<<B}
+B
+^ unexpected constant, expecting end-of-input
+
+<<A; %q
+A
+#{<<B}
+B
+^ unexpected constant, expecting end-of-input
+
diff --git a/test/prism/fixtures/heredoc_percent_q_newline_delimiter.txt b/test/prism/fixtures/heredoc_percent_q_newline_delimiter.txt
new file mode 100644
index 0000000000..dbfa0bf4b4
--- /dev/null
+++ b/test/prism/fixtures/heredoc_percent_q_newline_delimiter.txt
@@ -0,0 +1,22 @@
+%Q
+#{<<B}
+B
+
+%
+#{<<B}
+B
+
+<<A; %Q
+A
+#{<<B}
+B
+
+<<A; %
+A
+#{<<B}
+B
+
+# \r\n
+%Q
+#{<<B}
+B
diff --git a/test/prism/ruby/parser_test.rb b/test/prism/ruby/parser_test.rb
index c972f0962b..df290a6a8e 100644
--- a/test/prism/ruby/parser_test.rb
+++ b/test/prism/ruby/parser_test.rb
@@ -62,6 +62,9 @@ class ParserTest < TestCase
       "alias.txt",
       "seattlerb/bug_215.txt",
 
+      # %Q with newline delimiter and heredoc interpolation
+      "heredoc_percent_q_newline_delimiter.txt",
+
       # 1.. && 2
       "ranges.txt",
 
diff --git a/test/prism/ruby/ruby_parser_test.rb b/test/prism/ruby/ruby_parser_test.rb
index fae5077e20..4b7e9c93ed 100644
--- a/test/prism/ruby/ruby_parser_test.rb
+++ b/test/prism/ruby/ruby_parser_test.rb
@@ -37,6 +37,7 @@ class RubyParserTest < TestCase
       "alias.txt",
       "dsym_str.txt",
       "dos_endings.txt",
+      "heredoc_percent_q_newline_delimiter.txt",
       "heredocs_with_fake_newlines.txt",
       "heredocs_with_ignored_newlines.txt",
       "method_calls.txt",