tree-sitter-sed 0.7.0 → 0.9.0

package/common/grammar.js

@@ -13,6 +13,37 @@ function missingAtEndOrBoundary($, reason) {
   );
 }
 
+function blankSeparatedFileOperand($, name, operand) {
+  return seq(
+    $._blanks,
+    choice(operand, missingAtEndOrBoundary($, `missing_${name}`)),
+  );
+}
+
+function fileOperandForms($, name, operand) {
+  return [
+    blankSeparatedFileOperand($, name, operand),
+    seq(issueField($, "omitted_file_separator"), operand),
+    missingAtEndOrBoundary($, `missing_${name}`),
+  ];
+}
+
+function lineOperand($, first, rest) {
+  return prec.right(
+    seq(
+      choice(first, issueField($, "nul_character")),
+      repeat(choice(rest, issueField($, "nul_character"))),
+    ),
+  );
+}
+
+function commentText($) {
+  return choice(
+    namedExternal($, $._comment_text, "comment_text"),
+    issueField($, "nul_character"),
+  );
+}
+
 function missingCommandSeparator($) {
   return choice(
     issueNode($, "missing_command_separator"),
@@ -24,14 +55,6 @@ function functionVerb($, spelling) {
   return field("verb", alias(spelling, $.function_verb));
 }
 
-function leadingEmptyCommands($) {
-  return alias($._leading_empty_commands, $.empty_command);
-}
-
-function withLeadingEmptyCommands($, commands) {
-  return choice(commands, seq(leadingEmptyCommands($), optional(commands)));
-}
-
 const delimiterNames = [
   "regex_address_start",
   "escaped_regex_address_start",
@@ -139,16 +162,35 @@ const functionDefinitions = [
   },
 ];
 
-const nonWriteSubstitutionFlagRules = [
-  "occurrence_flag",
-  "global_flag",
-  "case_insensitive_flag",
-  "print_flag",
-];
+// A known verb never becomes an unknown function: address maxima are owned by
+// the excess address clauses, and a token that could also match a verb would
+// let a GLR branch that expects other verbs compete with the valid parse.
+const unknownFunctionCharacter = new RegExp(
+  `[^[:blank:][:digit:]$\\/\\\\!;}\\n${functionDefinitions
+    .map(({ spelling }) => spelling)
+    .join("")}]`,
+);
+
+// Letter flags are aliased at their use sites: a rule that is only a string
+// shares its token with the function verbs and would wrap an anonymous leaf.
+const letterSubstitutionFlags = {
+  global_flag: "g",
+  case_insensitive_flag: "i",
+  print_flag: "p",
+};
+
+function nonWriteSubstitutionFlags($) {
+  return [
+    $.occurrence_flag,
+    ...Object.entries(letterSubstitutionFlags).map(([rule, spelling]) =>
+      alias(spelling, $[rule]),
+    ),
+  ];
+}
 
 function postWriteSubstitutionFlagChoice($) {
   return choice(
-    ...nonWriteSubstitutionFlagRules.map((rule) => $[rule]),
+    ...nonWriteSubstitutionFlags($),
     alias("w", $.substitution_flag),
   );
 }
@@ -187,11 +229,6 @@ function delimiterRules() {
   return rules;
 }
 
-function choiceForRules($, names) {
-  const rules = names.map((name) => $[name]);
-  return rules.length === 1 ? rules[0] : choice(...rules);
-}
-
 function commandListRules() {
   return {
     script: ($) => optional(alias($._script_command_list, $.command_list)),
@@ -230,28 +267,15 @@ function commandListRules() {
             "default_output_suppression",
           ),
         ),
-        optional(namedExternal($, $._comment_text, "comment_text")),
+        repeat(commentText($)),
       ),
 
     _command_list: ($) =>
       choice($._final_line, seq($._terminated_line, optional($._command_list))),
 
-    _final_line: ($) =>
-      choice($._line_content, alias($._blanks, $.empty_command)),
-
-    _terminated_line: ($) =>
-      choice(
-        seq($._line_content, $._newline_separator),
-        alias($._empty_terminated_line, $.empty_command),
-      ),
-
-    _empty_terminated_line: ($) =>
-      seq(optional($._blanks), $._newline_separator),
+    _final_line: ($) => choice($._command_sequence, $._blanks),
 
-    _line_content: ($) => withLeadingEmptyCommands($, $._command_sequence),
-
-    _leading_empty_commands: ($) =>
-      seq(optional($._blanks), $._semicolon_separators),
+    _terminated_line: ($) => seq($._command_sequence, $._newline_separator),
 
     _command_sequence: ($) =>
       choice(
@@ -261,9 +285,9 @@ function commandListRules() {
         ),
         seq(
           $._recovered_line_terminated_command_item,
-          optional($._line_content),
+          optional(choice($._command_sequence, $._blanks)),
         ),
-        seq($._chainable_command_item, optional($._command_sequence_tail)),
+        seq($._separable_command_item, optional($._command_sequence_tail)),
         seq(
           $._unmatched_closing_brace_item,
           optional($._unmatched_closing_brace_tail_content),
@@ -272,7 +296,10 @@ function commandListRules() {
 
     _command_sequence_tail: ($) =>
       choice(
-        seq($._semicolon_separators, optional($._command_sequence)),
+        seq(
+          $._semicolon_separator,
+          optional(choice($._command_sequence, $._blanks)),
+        ),
         $._unmatched_closing_brace_tail,
       ),
 
@@ -295,6 +322,9 @@ function commandListRules() {
         ),
       ),
 
+    _separable_command_item: ($) =>
+      choice($.empty_command, $._chainable_command_item),
+
     _chainable_command_item: ($) =>
       choice(
         alias($._chainable_editing_command, $.editing_command),
@@ -312,39 +342,32 @@ function commandListRules() {
         $._line_terminated_command_item,
         seq(
           $._recovered_line_terminated_command_item,
-          optional($._block_line_content),
+          optional($._block_command_sequence),
         ),
         seq(
-          $._chainable_command_item,
-          optional($._block_command_sequence_tail),
+          $._separable_command_item,
+          optional(
+            seq($._semicolon_separator, optional($._block_command_sequence)),
+          ),
         ),
       ),
 
-    _block_command_sequence_tail: ($) =>
-      seq($._semicolon_separators, optional($._block_command_sequence)),
-
-    _block_line_content: ($) =>
-      withLeadingEmptyCommands($, $._block_command_sequence),
-
-    _block_line_content_before_close: ($) =>
-      withLeadingEmptyCommands($, $._block_command_sequence_before_close),
-
     _block_command_sequence_before_close: ($) =>
       choice(
         seq(
-          $._chainable_command_item,
-          $._semicolon_separators,
+          $._separable_command_item,
+          $._semicolon_separator,
           optional($._block_command_sequence_before_close),
         ),
         seq(
           $._recovered_line_terminated_command_item,
-          optional($._block_line_content_before_close),
+          optional($._block_command_sequence_before_close),
         ),
       ),
 
     _block_command_list: ($) =>
       choice(
-        $._block_line_content_before_close,
+        $._block_command_sequence_before_close,
         seq($._terminated_block_line, optional($._block_command_list)),
       ),
 
@@ -354,26 +377,18 @@ function commandListRules() {
     _block_command_list_missing_separator: ($) =>
       choice(
         missingCommandSeparator($),
-        seq(
-          optional(leadingEmptyCommands($)),
-          $._block_command_sequence,
-          missingCommandSeparator($),
-        ),
+        seq($._block_command_sequence, missingCommandSeparator($)),
         seq($._terminated_block_line, $._block_command_list_missing_separator),
       ),
 
     _terminated_block_line: ($) =>
-      choice(
-        seq($._block_line_content, $._newline_separator),
-        alias($._empty_terminated_line, $.empty_command),
-      ),
+      seq($._block_command_sequence, $._newline_separator),
 
     _newline_separator: ($) => alias("\n", $.command_separator),
 
-    _semicolon_separators: ($) => prec.right(repeat1($._semicolon_separator)),
+    _semicolon_separator: ($) => alias(";", $.command_separator),
 
-    _semicolon_separator: ($) =>
-      prec.right(seq(alias(";", $.command_separator), optional($._blanks))),
+    empty_command: ($) => seq(optional($._blanks), $._empty_command_marker),
 
     _blanks: () => token(/[[:blank:]]+/),
   };
@@ -434,12 +449,10 @@ function addressRules(mode) {
           field("second", $.address),
         ),
         seq(
-          field("first", $.address),
-          commaSeparator($),
-          $._omitted_second_address_issue,
-        ),
-        seq(
-          issueField($, "omitted_first_address"),
+          choice(
+            field("first", $.address),
+            issueField($, "omitted_first_address"),
+          ),
           commaSeparator($),
           $._omitted_second_address_issue,
         ),
@@ -516,7 +529,6 @@ function addressRules(mode) {
 
     address: addressChoice,
 
-    // Keep maximum-specific GLR paths distinct until the function verb.
     _max0_address: addressChoice,
 
     _max1_address: addressChoice,
@@ -541,65 +553,67 @@ function addressRules(mode) {
   };
 }
 
+function delimitedFunction($, spelling, name, first, middleReason, rest) {
+  return seq(
+    functionVerb($, spelling),
+    choice(
+      seq(
+        field("opening", delimiter($, `${name}_start`)),
+        optional(first),
+        choice(
+          seq(field("middle", delimiter($, `${name}_middle`)), ...rest),
+          field("middle", unterminatedDelimiter($, middleReason)),
+        ),
+      ),
+      missingOpeningDelimiter($),
+    ),
+  );
+}
+
 function operandRules(mode) {
   const expression = mode === "bre" ? "basic_reg_exp" : "extended_reg_exp";
 
   function substitutionFlagChoice($) {
-    const rules = nonWriteSubstitutionFlagRules.map((rule) => $[rule]);
-    rules.push(issueField($, "invalid_substitution_flag"));
-    return choice(...rules);
+    return choice(
+      ...nonWriteSubstitutionFlags($),
+      issueField($, "invalid_substitution_flag"),
+    );
   }
 
   return {
-    _substitute_function: ($) =>
-      choice(
-        seq(
-          $._complete_substitute_function,
-          optional(
-            field("flags", alias($._substitution_flags, $.substitution_flags)),
-          ),
-        ),
-        $._incomplete_substitute_function,
-      ),
-
-    _complete_substitute_function: ($) =>
-      seq(
-        functionVerb($, "s"),
-        field("opening", delimiter($, "substitute_start")),
-        optional(field("expression", $[expression])),
-        field("middle", delimiter($, "substitute_middle")),
-        optional(field("replacement", $.replacement)),
-        field("closing", delimiter($, "substitute_end")),
-      ),
-
-    _incomplete_substitute_function: ($) =>
-      seq(
-        functionVerb($, "s"),
-        choice(
-          missingOpeningDelimiter($),
-          seq(
-            field("opening", delimiter($, "substitute_start")),
-            optional(field("expression", $[expression])),
-            choice(
-              seq(
-                field("middle", delimiter($, "substitute_middle")),
-                optional(field("replacement", $.replacement)),
-                field("closing", unterminatedDelimiter($, "replacement")),
+    substitute_function: ($) =>
+      delimitedFunction(
+        $,
+        "s",
+        "substitute",
+        field("expression", $[expression]),
+        "regular_expression",
+        [
+          optional(field("replacement", $.replacement)),
+          choice(
+            seq(
+              field("closing", delimiter($, "substitute_end")),
+              optional(
+                field(
+                  "flags",
+                  alias($._substitution_flags, $.substitution_flags),
+                ),
               ),
-              field("middle", unterminatedDelimiter($, "regular_expression")),
             ),
+            field("closing", unterminatedDelimiter($, "replacement")),
           ),
-        ),
+        ],
       ),
 
     replacement: ($) =>
       repeat1(
         choice(
           $.replacement_literal,
+          issueField($, "nul_character"),
           $.matched_text_reference,
           $.replacement_backreference,
           $.replacement_escaped_delimiter,
-          $.ambiguous_replacement_delimiter_escape,
+          issueField($, "replacement_ampersand_delimiter_escape"),
           $.replacement_escape,
           $.escaped_newline,
           issueField($, "unspecified_replacement_escape"),
@@ -607,45 +621,17 @@ function operandRules(mode) {
         ),
       ),
 
-    replacement_literal: ($) =>
-      namedExternal($, $._replacement_literal, "replacement_literal_token"),
+    replacement_literal: ($) => $._replacement_literal,
 
-    matched_text_reference: ($) =>
-      namedExternal(
-        $,
-        $._replacement_match_reference,
-        "matched_text_reference_token",
-      ),
+    matched_text_reference: ($) => $._replacement_match_reference,
 
-    replacement_backreference: ($) =>
-      namedExternal(
-        $,
-        $._replacement_backreference,
-        "replacement_backreference_token",
-      ),
+    replacement_backreference: ($) => $._replacement_backreference,
 
-    replacement_escaped_delimiter: ($) =>
-      field(
-        "token",
-        namedExternal(
-          $,
-          $._replacement_escaped_delimiter,
-          "escaped_delimiter_token",
-        ),
-      ),
-
-    ambiguous_replacement_delimiter_escape: ($) =>
-      issueField($, "replacement_ampersand_delimiter_escape"),
+    replacement_escaped_delimiter: ($) => $._replacement_escaped_delimiter,
 
-    replacement_escape: ($) =>
-      namedExternal(
-        $,
-        $._replacement_escape_sequence,
-        "replacement_escape_token",
-      ),
+    replacement_escape: ($) => $._replacement_escape_sequence,
 
-    escaped_newline: ($) =>
-      namedExternal($, $._replacement_escaped_newline, "escaped_newline_token"),
+    escaped_newline: ($) => $._replacement_escaped_newline,
 
     _substitution_flags: ($) =>
       choice(
@@ -663,65 +649,45 @@ function operandRules(mode) {
 
     occurrence_flag: () => /[[:digit:]]+/,
 
-    global_flag: () => "g",
-
-    case_insensitive_flag: () => "i",
-
-    print_flag: () => "p",
-
-    write_flag: ($) =>
-      seq(
+    write_flag: ($) => {
+      const wfile = field("wfile", alias($._substitution_wfile, $.wfile));
+      return seq(
         field("verb", alias("w", $.substitution_flag)),
         choice(
           seq(
             $._flag_after_write_marker,
             repeat1(postWriteSubstitutionFlagChoice($)),
-            $._blanks,
-            choice(
-              field("wfile", alias($._substitution_wfile, $.wfile)),
-              missingAtEndOrBoundary($, "missing_wfile"),
-            ),
-          ),
-          seq($._blanks, field("wfile", alias($._substitution_wfile, $.wfile))),
-          seq($._blanks, missingAtEndOrBoundary($, "missing_wfile")),
-          seq(
-            issueField($, "omitted_file_separator"),
-            field("wfile", alias($._substitution_wfile, $.wfile)),
+            blankSeparatedFileOperand($, "wfile", wfile),
           ),
-          missingAtEndOrBoundary($, "missing_wfile"),
+          ...fileOperandForms($, "wfile", wfile),
         ),
-      ),
+      );
+    },
 
     translate_function: ($) =>
-      seq(
-        functionVerb($, "y"),
-        choice(
-          seq(
-            field("opening", delimiter($, "translate_start")),
-            optional(field("string1", $.translation_string)),
+      delimitedFunction(
+        $,
+        "y",
+        "translate",
+        field("string1", $.translation_string),
+        "translation",
+        [
+          optional(field("string2", $.translation_string)),
+          field(
+            "closing",
             choice(
-              seq(
-                field("middle", delimiter($, "translate_middle")),
-                optional(field("string2", $.translation_string)),
-                field(
-                  "closing",
-                  choice(
-                    delimiter($, "translate_end"),
-                    unterminatedDelimiter($, "translation"),
-                  ),
-                ),
-              ),
-              field("middle", unterminatedDelimiter($, "translation")),
+              delimiter($, "translate_end"),
+              unterminatedDelimiter($, "translation"),
             ),
           ),
-          missingOpeningDelimiter($),
-        ),
+        ],
       ),
 
     translation_string: ($) =>
       repeat1(
         choice(
           $.translation_literal,
+          issueField($, "nul_character"),
           $.translation_escape,
           $.translation_escaped_delimiter,
           issueField($, "undefined_translation_escape"),
@@ -729,18 +695,11 @@ function operandRules(mode) {
         ),
       ),
 
-    translation_literal: ($) =>
-      namedExternal($, $._translate_literal, "translation_literal_token"),
+    translation_literal: ($) => $._translate_literal,
 
-    translation_escape: ($) =>
-      namedExternal($, $._translate_escape, "translation_escape_token"),
+    translation_escape: ($) => $._translate_escape,
 
-    translation_escaped_delimiter: ($) =>
-      namedExternal(
-        $,
-        $._translate_escaped_delimiter,
-        "escaped_delimiter_token",
-      ),
+    translation_escaped_delimiter: ($) => $._translate_escaped_delimiter,
   };
 }
 
@@ -755,57 +714,62 @@ function functionRules() {
         repeat1(
           choice(
             $.text_literal,
+            issueField($, "nul_character"),
             $.text_backslash_escape,
             $.text_escaped_newline,
             issueField($, "unspecified_text_escape"),
           ),
         ),
-        optional(issueField($, "missing_text")),
-        $._text_end,
+        $._text_tail,
       ),
 
+    _text_tail: ($) =>
+      seq(optional(issueField($, "missing_text")), $._text_end),
+
     _text_end: ($) => choice($._text_line_end, $._text_eof),
 
-    text_literal: ($) =>
-      namedExternal($, $._text_literal, "text_literal_token"),
+    text_literal: ($) => $._text_literal,
 
-    text_backslash_escape: ($) =>
-      namedExternal($, $._text_backslash_escape, "text_backslash_escape_token"),
+    text_backslash_escape: ($) => $._text_backslash_escape,
 
-    text_escaped_newline: ($) =>
-      namedExternal($, $._text_escaped_newline, "text_escaped_newline_token"),
+    text_escaped_newline: ($) => $._text_escaped_newline,
 
     text_introducer: ($) =>
       namedExternal($, $._text_command_start, "text_introducer_token"),
 
-    rfile: ($) => namedExternal($, $._file_argument, "rfile_token"),
+    _incomplete_text_introducer: ($) =>
+      issueField($, "incomplete_text_introducer"),
 
-    wfile: ($) => namedExternal($, $._file_argument, "wfile_token"),
+    rfile: ($) => lineOperand($, $._file_argument, $._line_word),
+
+    wfile: ($) => lineOperand($, $._file_argument, $._line_word),
 
     _substitution_wfile: ($) =>
-      namedExternal($, $._substitution_wfile_argument, "wfile_token"),
+      lineOperand(
+        $,
+        $._substitution_wfile_argument,
+        $._substitution_wfile_continuation,
+      ),
 
-    label: ($) => namedExternal($, $._line_word, "label_token"),
+    label: ($) =>
+      prec.right(repeat1(choice($._line_word, issueField($, "nul_character")))),
 
-    comment: ($) => namedExternal($, $._comment_text, "comment_text"),
+    comment: ($) => prec.right(repeat1(commentText($))),
 
-    closing_brace: ($) =>
-      choice(
-        namedExternal($, $._right_brace, "closing_brace_token"),
-        issueField($, "missing_closing_brace"),
+    comment_function: ($) =>
+      prec.right(
+        seq(functionVerb($, "#"), optional(field("comment", $.comment))),
       ),
+
+    closing_brace: ($) =>
+      choice($._present_closing_brace, issueField($, "missing_closing_brace")),
+
+    _present_closing_brace: ($) =>
+      namedExternal($, $._right_brace, "closing_brace_token"),
   };
 
   function fileForm(form) {
-    const missingFileReason = `missing_${form}`;
-    return ($) => [
-      choice(
-        seq($._blanks, field(form, $[form])),
-        seq($._blanks, missingAtEndOrBoundary($, missingFileReason)),
-        seq(issueField($, "omitted_file_separator"), field(form, $[form])),
-        missingAtEndOrBoundary($, missingFileReason),
-      ),
-    ];
+    return ($) => [choice(...fileOperandForms($, form, field(form, $[form])))];
   }
 
   const formArguments = {
@@ -818,10 +782,11 @@ function functionRules() {
       choice(
         seq(
           field("introducer", $.text_introducer),
-          choice(
-            field("text", $.text),
-            seq(optional(issueField($, "missing_text")), $._text_end),
-          ),
+          choice(field("text", $.text), $._text_tail),
+        ),
+        field(
+          "introducer",
+          alias($._incomplete_text_introducer, $.text_introducer),
         ),
         missingAtEndOrBoundary($, "missing_text_introducer"),
       ),
@@ -830,7 +795,10 @@ function functionRules() {
       optional(
         prec.right(
           seq(
-            field("separator", alias(" ", $.argument_separator)),
+            field(
+              "separator",
+              namedExternal($, $._argument_separator, "argument_separator"),
+            ),
             optional(field("label", $.label)),
           ),
         ),
@@ -844,7 +812,6 @@ function functionRules() {
     ],
     rfile: fileForm("rfile"),
     wfile: fileForm("wfile"),
-    comment: ($) => [optional(field("comment", $.comment))],
   };
 
   for (const { rule, spelling } of noArgumentDefinitions) {
@@ -863,124 +830,101 @@ function functionRules() {
 }
 
 function editingCommandRules() {
-  const regularDefinitions = functionDefinitions.filter(
-    ({ form }) => form !== "substitute",
-  );
-  const chainable = regularDefinitions.filter(
-    ({ lineTerminated }) => !lineTerminated,
-  );
-  const lineTerminated = regularDefinitions.filter(
-    ({ lineTerminated: isLineTerminated }) => isLineTerminated,
-  );
-
-  function functionsByMaximum(definitions, maximum) {
-    return definitions
-      .filter(({ maxAddresses = 2 }) => maxAddresses === maximum)
-      .map(({ rule }) => rule);
-  }
-
-  function wrapperName(kind, maximum) {
-    return `_${kind}_${maximum}_address_function`;
-  }
+  const addressClauses = {
+    0: ($) => alias($._max0_address_clause, $.address_clause),
+    1: ($) => alias($._max1_address_clause, $.address_clause),
+    2: ($) => $.address_clause,
+  };
 
-  function functionWrapper($, name) {
-    return alias($[name], $.function);
+  // Keep address, issue, and function rules separate by address maximum so
+  // GLR paths cannot merge before the function verb.
+  const wrappers = [];
+  for (const [kind, isLineTerminated] of [
+    ["chainable", false],
+    ["line_terminated", true],
+  ]) {
+    for (const maximum of [0, 1, 2]) {
+      const names = functionDefinitions
+        .filter(
+          ({ lineTerminated = false, maxAddresses = 2 }) =>
+            lineTerminated === isLineTerminated && maxAddresses === maximum,
+        )
+        .map(({ rule }) => rule);
+      if (names.length > 0) {
+        wrappers.push({
+          kind,
+          maximum,
+          name: `_${kind}_${maximum}_address_function`,
+          names,
+        });
+      }
+    }
   }
 
-  function addressClauseForMaximum($, maximum) {
-    if (maximum === 0) {
-      return alias($._max0_address_clause, $.address_clause);
-    }
-    if (maximum === 1) {
-      return alias($._max1_address_clause, $.address_clause);
-    }
-    return $.address_clause;
+  function addressesPrefix($, addresses) {
+    return seq(field("addresses", addresses), optional($._blanks));
   }
 
   function addressedCommand($, addresses, selectedFunction) {
     return seq(
       optional($._blanks),
-      optional(seq(field("addresses", addresses), optional($._blanks))),
+      optional(addressesPrefix($, addresses)),
       optional(field("negation", $.negation)),
       field("function", selectedFunction),
     );
   }
 
-  function addressedFunction($, functionRule) {
-    return addressedCommand(
-      $,
-      $.address_clause,
-      alias(functionRule, $.function),
-    );
-  }
-
-  function addressedForms($, definitions, kind) {
-    const forms = [];
-    for (const maximum of [0, 1, 2]) {
-      const names = functionsByMaximum(definitions, maximum);
-      if (names.length === 0) {
-        continue;
-      }
-      forms.push(
-        addressedCommand(
-          $,
-          addressClauseForMaximum($, maximum),
-          functionWrapper($, wrapperName(kind, maximum)),
+  function addressedForms($, kind) {
+    return choice(
+      ...wrappers
+        .filter((wrapper) => wrapper.kind === kind)
+        .map(({ maximum, name }) =>
+          addressedCommand(
+            $,
+            addressClauses[maximum]($),
+            alias($[name], $.function),
+          ),
         ),
-      );
-    }
-
-    return choice(...forms);
+    );
   }
 
   const rules = {
     _chainable_editing_command: ($) =>
       seq(
-        choice(
-          addressedForms($, chainable, "chainable"),
-          addressedFunction($, $._chainable_substitute_function),
-        ),
+        addressedForms($, "chainable"),
         optional(issueField($, "unexpected_command_text")),
       ),
 
     _line_terminated_editing_command: ($) =>
       seq(
-        addressedForms($, lineTerminated, "line_terminated"),
+        addressedForms($, "line_terminated"),
         optional(issueField($, "unexpected_command_text")),
       ),
 
     _recovered_line_terminated_editing_command: ($) =>
-      prec.right(
-        seq(
-          $._line_terminated_editing_command,
-          issueField($, "forbidden_command_separator"),
-          optional($._blanks),
-        ),
+      seq(
+        $._line_terminated_editing_command,
+        issueField($, "forbidden_command_separator"),
       ),
 
     _recovered_editing_command: ($) =>
       choice(
-        addressedFunction($, $._unknown_function),
-        seq(
-          optional($._blanks),
-          optional(
-            seq(field("addresses", $.address_clause), optional($._blanks)),
-          ),
-          field("negation", $.negation),
-          field("function", alias($._reserved_unknown_function, $.function)),
+        addressedCommand(
+          $,
+          $.address_clause,
+          alias($._unknown_function, $.function),
         ),
         seq(
           optional($._blanks),
-          field("addresses", alias($._double_address_clause, $.address_clause)),
-          optional($._blanks),
+          optional(addressesPrefix($, $.address_clause)),
+          field("negation", $.negation),
           field("function", alias($._reserved_unknown_function, $.function)),
         ),
         seq(
           optional($._blanks),
           choice(
             seq(
-              field("addresses", $.address_clause),
-              optional($._blanks),
+              addressesPrefix($, $.address_clause),
               optional(field("negation", $.negation)),
             ),
             field("negation", $.negation),
@@ -1003,9 +947,6 @@ function editingCommandRules() {
 
     _missing_function: ($) => missingAtEndOrBoundary($, "missing_function"),
 
-    _chainable_substitute_function: ($) =>
-      alias($._substitute_function, $.substitute_function),
-
     negation: ($) =>
       seq(
         field("operator", alias("!", $.negation_operator)),
@@ -1019,16 +960,8 @@ function editingCommandRules() {
       ),
   };
 
-  for (const [kind, definitions] of [
-    ["chainable", chainable],
-    ["line_terminated", lineTerminated],
-  ]) {
-    for (const maximum of [0, 1, 2]) {
-      const names = functionsByMaximum(definitions, maximum);
-      if (names.length > 0) {
-        rules[wrapperName(kind, maximum)] = ($) => choiceForRules($, names);
-      }
-    }
+  for (const { name, names } of wrappers) {
+    rules[name] = ($) => choice(...names.map((name) => $[name]));
   }
 
   return rules;
@@ -1100,15 +1033,31 @@ function issueDefinitions(mode) {
       outcome: "undefined_syntax",
       rule: ($) => $._regex_malformed_bracket_term,
     },
+    {
+      id: "invalid_character_class_name",
+      reason: "malformed_bracket_term",
+      outcome: "undefined_syntax",
+      rule: ($) => namedExternal($, $._regex_invalid_class_name, "class_name"),
+    },
+    {
+      reason: "nul_character",
+      outcome: "nonconforming_syntax",
+      rule: ($) => $._nul_character,
+    },
+    {
+      reason: "invalid_regular_expression_character",
+      outcome: "invalid_syntax",
+      rule: ($) => $._invalid_character,
+    },
     {
       reason: "character_class_range_start",
       outcome: "undefined_syntax",
-      rule: ($) => $._nonportable_range_start_marker,
+      rule: ($) => seq($.character_class, $._nonportable_range_start_marker),
     },
     {
       reason: "character_class_range_end",
       outcome: "undefined_syntax",
-      rule: ($) => $._nonportable_range_end_marker,
+      rule: ($) => seq($._nonportable_range_end_marker, $.character_class),
     },
     {
       reason: "shared_range_endpoint",
@@ -1132,7 +1081,6 @@ function issueDefinitions(mode) {
       outcome: "undefined_syntax",
       rule: missing("omitted_first_address"),
     },
-    // The marker is shared, but maximum-specific reductions must not merge.
     ...[0, 1].map((maximum) => ({
       id: `omitted_first_address_unit${maximum}`,
       reason: "omitted_address",
@@ -1181,17 +1129,39 @@ function issueDefinitions(mode) {
     {
       reason: "malformed_interval",
       outcome: "undefined_syntax",
-      rule: ($) => $._regex_invalid_interval,
+      rule: ($) =>
+        prec.right(
+          repeat1(
+            choice(
+              $._regex_invalid_interval,
+              issueField($, "invalid_regular_expression_character"),
+            ),
+          ),
+        ),
     },
     {
       reason: "leading_duplication_symbol",
       outcome: "undefined_syntax",
-      rule: ($) => $._regex_leading_duplication_marker,
+      rule: ($) =>
+        seq(
+          $._regex_leading_duplication_marker,
+          field(
+            "operator",
+            mode === "bre" ? $.bre_dupl_symbol : $.ere_dupl_symbol,
+          ),
+        ),
     },
     {
       reason: "adjacent_duplication_symbol",
       outcome: "undefined_syntax",
-      rule: ($) => $._regex_adjacent_duplication_marker,
+      rule: ($) =>
+        seq(
+          $._regex_adjacent_duplication_marker,
+          field(
+            "operator",
+            mode === "bre" ? $.bre_dupl_symbol : $.ere_dupl_symbol,
+          ),
+        ),
     },
     ...(mode === "ere"
       ? [
@@ -1215,22 +1185,26 @@ function issueDefinitions(mode) {
     {
       reason: "undefined_translation_escape",
       outcome: "undefined_syntax",
-      rule: ($) => $._translate_nonportable_escape,
+      rule: ($) =>
+        choice(
+          $._translate_nonportable_escape,
+          seq($._escape_prefix, issueField($, "nul_character")),
+        ),
     },
     {
       reason: "equivalence_class_range_start",
       outcome: "unspecified_syntax",
-      rule: ($) => $._nonportable_range_start_marker,
+      rule: ($) => seq($.equivalence_class, $._nonportable_range_start_marker),
     },
     {
       reason: "equivalence_class_range_end",
       outcome: "unspecified_syntax",
-      rule: ($) => $._nonportable_range_end_marker,
+      rule: ($) => seq($._nonportable_range_end_marker, $.equivalence_class),
     },
     {
       reason: "ambiguous_bracket_expression",
       outcome: "unspecified_syntax",
-      rule: ($) => $._ambiguous_bracket_expression_marker,
+      rule: ($) => alias($._ambiguous_bracket_expression, $.bracket_expression),
     },
     {
       reason: "blanks_after_negation",
@@ -1240,7 +1214,11 @@ function issueDefinitions(mode) {
     {
       reason: "unspecified_replacement_escape",
       outcome: "unspecified_syntax",
-      rule: ($) => $._replacement_nonportable_escape,
+      rule: ($) =>
+        choice(
+          $._replacement_nonportable_escape,
+          seq($._escape_prefix, issueField($, "nul_character")),
+        ),
     },
     {
       reason: "special_delimiter_escape",
@@ -1255,33 +1233,49 @@ function issueDefinitions(mode) {
     {
       reason: "unspecified_text_escape",
       outcome: "unspecified_syntax",
-      rule: ($) => $._text_unspecified_escape,
+      rule: ($) =>
+        choice(
+          $._text_unspecified_escape,
+          seq($._escape_prefix, issueField($, "nul_character")),
+        ),
     },
     ...(mode === "bre"
       ? [
           {
             reason: "bre_vertical_line_escape",
             outcome: "implementation_defined_syntax",
-            rule: ($) => $._bre_vertical_line_escape_marker,
+            rule: ($) =>
+              field(
+                "token",
+                namedExternal($, $._regex_bre_vertical_line_escape, "back_bar"),
+              ),
           },
           {
             reason: "bre_question_mark_escape",
             outcome: "implementation_defined_syntax",
-            rule: ($) => $._bre_question_mark_escape_marker,
+            rule: ($) =>
+              field(
+                "token",
+                namedExternal($, $._regex_bre_question_mark_escape, "back_qm"),
+              ),
           },
           {
             reason: "bre_plus_escape",
             outcome: "implementation_defined_syntax",
-            rule: ($) => $._bre_plus_escape_marker,
+            rule: ($) =>
+              field(
+                "token",
+                namedExternal($, $._regex_bre_plus_escape, "back_plus"),
+              ),
           },
           {
             reason: "bre_subexpression_left_anchor",
-            outcome: "invalid_syntax",
+            outcome: "nonconforming_syntax",
             rule: ($) => $._regex_bre_subexpression_caret,
           },
           {
             reason: "bre_subexpression_right_anchor",
-            outcome: "invalid_syntax",
+            outcome: "nonconforming_syntax",
             rule: ($) => $._regex_bre_subexpression_dollar,
           },
         ]
@@ -1321,7 +1315,8 @@ function issueDefinitions(mode) {
     {
       reason: "unknown_function",
       outcome: "nonconforming_syntax",
-      rule: () => token(prec(-2, /[^[:blank:][:digit:]$\/\\!;{}#\n]/)),
+      rule: ($) =>
+        choice(token(prec(-2, unknownFunctionCharacter)), $._invalid_character),
     },
     {
       id: "reserved_unknown_function",
@@ -1332,16 +1327,23 @@ function issueDefinitions(mode) {
     {
       reason: "unexpected_command_text",
       outcome: "nonconforming_syntax",
-      rule: () =>
-        choice(
-          token.immediate(prec(-10, /[[:blank:]]+/)),
-          token.immediate(prec(-10, /[[:blank:]]*[^[:blank:];}\n][^;}\n]*/)),
+      rule: ($) =>
+        repeat1(
+          choice(
+            token.immediate(prec(-10, /[[:blank:]]+/)),
+            token.immediate(
+              // biome-ignore lint/suspicious/noControlCharactersInRegex: NUL must remain a separate syntax issue.
+              prec(-10, /[[:blank:]]*[^[:blank:];}\n\x00][^;}\n\x00]*/),
+            ),
+            issueField($, "nul_character"),
+            $._invalid_character,
+          ),
         ),
     },
     {
       reason: "forbidden_command_separator",
       outcome: "nonconforming_syntax",
-      rule: () => token.immediate(";"),
+      rule: ($) => alias(token.immediate(";"), $.command_separator),
     },
     {
       reason: "blanks_around_address_separator",
@@ -1361,7 +1363,7 @@ function issueDefinitions(mode) {
     {
       reason: "unmatched_closing_brace",
       outcome: "nonconforming_syntax",
-      rule: ($) => $._right_brace,
+      rule: ($) => alias($._present_closing_brace, $.closing_brace),
     },
     {
       reason: "missing_command_separator",
@@ -1388,7 +1390,11 @@ function issueDefinitions(mode) {
     {
       reason: "invalid_delimiter",
       outcome: "nonconforming_syntax",
-      rule: () => "\\",
+      rule: ($) =>
+        field(
+          "token",
+          alias(choice("\\", $._invalid_character), $.delimiter_token),
+        ),
     },
     {
       reason: "unterminated_regular_expression",
@@ -1449,6 +1455,11 @@ function issueDefinitions(mode) {
       outcome: "incomplete_syntax",
       rule: missing("missing_text_introducer"),
     },
+    {
+      reason: "incomplete_text_introducer",
+      outcome: "incomplete_syntax",
+      rule: ($) => $._text_incomplete_introducer,
+    },
     {
       reason: "missing_text",
       outcome: "incomplete_syntax",
@@ -1562,10 +1573,13 @@ function externalTokens($, mode) {
     $._translate_middle,
     $._translate_end,
     $._regex_literal,
+    $._invalid_character,
+    $._nul_character,
     $._regex_beginning_anchor,
     $._regex_end_anchor,
     $._regex_period,
     $._regex_quoted_escape,
+    $._escape_prefix,
     $._regex_newline_escape,
     $._regex_escaped_delimiter,
     $._regex_special_escaped_delimiter,
@@ -1580,9 +1594,6 @@ function externalTokens($, mode) {
           $._regex_bre_plus_escape,
           $._regex_bre_subexpression_caret,
           $._regex_bre_subexpression_dollar,
-          $._bre_vertical_line_escape_marker,
-          $._bre_question_mark_escape_marker,
-          $._bre_plus_escape_marker,
           $._regex_unmatched_interval_close,
         ]
       : []),
@@ -1614,6 +1625,7 @@ function externalTokens($, mode) {
     $._regex_bracket_trailing_hyphen,
     $._regex_open_colon,
     $._regex_class_name,
+    $._regex_invalid_class_name,
     $._regex_colon_close,
     $._regex_open_dot,
     $._regex_coll_elem_single,
@@ -1651,6 +1663,7 @@ function externalTokens($, mode) {
     $._invalid_substitution_flag,
     $._flag_after_write_marker,
     $._text_command_start,
+    $._text_incomplete_introducer,
     $._text_literal,
     $._text_backslash_escape,
     $._text_escaped_newline,
@@ -1661,8 +1674,11 @@ function externalTokens($, mode) {
     $._comment_text,
     $._file_argument,
     $._substitution_wfile_argument,
+    $._substitution_wfile_continuation,
     $._line_word,
+    $._argument_separator,
     $._right_brace,
+    $._empty_command_marker,
     $._reserved_unknown_function_token,
     $._regex_incomplete_group,
     $._regex_incomplete_bracket_term,
@@ -1692,7 +1708,6 @@ function defineGrammar(name, mode) {
     extras: () => [],
 
     conflicts: ($) => [
-      [$.address_clause, $._recovered_editing_command],
       [$.address_clause, $._max1_address_clause],
       [$._double_address_clause, $._excess_address_unit1_reason],
       [$.address, $._max0_address],