tree-sitter-sed 0.18.0 → 0.19.0

package/common/grammar.js

@@ -1,76 +1,5 @@
-import {
-  defineIssueRules,
-  issueField,
-  issueNode,
-  namedExternal,
-} from "./dsl.js";
-import regularExpressionRules from "./regex.js";
-
-function missingAtEndOrBoundary($, reason) {
-  return choice(
-    issueField($, reason),
-    issueField($, `nonconforming_${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 sourcePiece($, external, leaf) {
-  return choice(
-    namedExternal($, external, leaf),
-    issueField($, "nul_character"),
-    issueField($, "invalid_encoding"),
-  );
-}
-
-function sourcePieces($, leaf, external) {
-  return prec.right(repeat1(sourcePiece($, external, leaf)));
-}
-
-function lineOperand($, first, rest) {
-  return prec.right(
-    seq(
-      sourcePiece($, first, "file_literal"),
-      repeat(sourcePiece($, rest, "file_literal")),
-    ),
-  );
-}
-
-function operandAtoms($, literal, ...atoms) {
-  return repeat1(
-    choice(
-      literal,
-      seq($._escape_prefix, issueField($, "invalid_encoding")),
-      issueField($, "nul_character"),
-      issueField($, "invalid_encoding"),
-      ...atoms,
-    ),
-  );
-}
-
-function missingCommandSeparator($) {
-  return choice(
-    issueNode($, "missing_command_separator"),
-    issueNode($, "incomplete_missing_command_separator"),
-  );
-}
-
-function functionVerb($, spelling) {
-  return field("verb", alias(spelling, $.function_verb));
-}
+import { defineIssueRules, issueField, namedExternal } from "./dsl.js";
+import { breRules, ereRules } from "./regex.js";
 
 const functionDefinitions = [
   { rule: "block_function", spelling: "{", form: "block" },
@@ -120,6 +49,12 @@ const functionDefinitions = [
     lineTerminated: true,
   },
   { rule: "substitute_function", spelling: "s", form: "substitute" },
+  {
+    rule: "_write_substitute_function",
+    spelling: "s",
+    form: "substitute",
+    writeTerminated: true,
+  },
   {
     rule: "test_function",
     spelling: "t",
@@ -155,37 +90,160 @@ const functionDefinitions = [
   },
 ];
 
-// Matching known verbs here creates GLR branches that compete with valid
-// commands.
 const unknownFunctionCharacter = new RegExp(
   `[^ \\t0-9$\\/\\\\!;}\\n${functionDefinitions
     .map(({ spelling }) => spelling)
     .join("")}]`,
 );
 
-// String-only flag rules share verb tokens and would wrap anonymous leaves.
-const letterSubstitutionFlags = {
-  global_flag: "g",
-  case_insensitive_flag: "i",
-  print_flag: "p",
-};
+function missingAtEndOrBoundary($, reason) {
+  return choice(
+    issueField($, reason),
+    issueField($, `nonconforming_${reason}`),
+  );
+}
 
-function nonWriteSubstitutionFlags($) {
+function blankSeparatedFileOperand($, name, operand) {
+  return seq(
+    $._blanks,
+    choice(operand, missingAtEndOrBoundary($, `missing_${name}`)),
+  );
+}
+
+function fileOperandForms($, name, operand) {
   return [
-    $.occurrence_flag,
-    ...Object.entries(letterSubstitutionFlags).map(([rule, spelling]) =>
-      alias(spelling, $[rule]),
-    ),
+    blankSeparatedFileOperand($, name, operand),
+    seq(issueField($, "omitted_file_separator"), operand),
+    missingAtEndOrBoundary($, `missing_${name}`),
   ];
 }
 
-function postWriteSubstitutionFlagChoice($) {
+function sourcePiece($, external, leaf) {
+  return choice(
+    namedExternal($, external, leaf),
+    issueField($, "nul_character"),
+    issueField($, "invalid_encoding"),
+  );
+}
+
+function lineOperand($, first, rest) {
+  return prec.right(
+    seq(
+      sourcePiece($, first, "file_literal"),
+      repeat(sourcePiece($, rest, "file_literal")),
+    ),
+  );
+}
+
+function operandAtoms($, literal, ...atoms) {
+  return repeat1(
+    choice(
+      literal,
+      seq($._escape_prefix, issueField($, "invalid_encoding")),
+      issueField($, "nul_character"),
+      issueField($, "invalid_encoding"),
+      ...atoms,
+    ),
+  );
+}
+
+function missingCommandSeparator($) {
   return choice(
-    ...nonWriteSubstitutionFlags($),
-    alias("w", $.substitution_flag),
+    issueField($, "missing_command_separator"),
+    issueField($, "incomplete_missing_command_separator"),
   );
 }
 
+function functionVerb($, spelling) {
+  return field("verb", alias(spelling, $.function_verb));
+}
+
+function substitutionFlag($, kind, seen) {
+  if ((kind === 1 && seen & 2) || (kind === 2 && seen & 1)) {
+    return issueField(
+      $,
+      kind === 1 ? "conflicting_global_flag" : "conflicting_occurrence_flag",
+    );
+  }
+  return kind === 1 ? alias("g", $.global_flag) : $.occurrence_flag;
+}
+
+function substitutionFlagRules() {
+  const rules = {};
+  for (const ending of ["plain", "write", "postwrite"]) {
+    for (const seen of [0, 1, 2, 3]) {
+      rules[`_flags_${ending}_${seen}`] = ($) => {
+        const steady = [
+          alias("i", $.case_insensitive_flag),
+          alias("p", $.print_flag),
+          ...(ending === "postwrite"
+            ? [
+                choice(
+                  alias("w", $.substitution_flag),
+                  issueField($, "nonfinal_write_flag"),
+                ),
+              ]
+            : [
+                issueField($, "invalid_substitution_flag"),
+                issueField($, "invalid_encoding"),
+              ]),
+        ];
+        const transitions = [];
+        for (const kind of [1, 2]) {
+          const flag = substitutionFlag($, kind, seen);
+          if (seen & kind) {
+            steady.push(flag);
+          } else {
+            const tail = $[`_flags_${ending}_${seen | kind}`];
+            transitions.push(
+              seq(flag, ending === "write" ? tail : optional(tail)),
+            );
+          }
+        }
+        if (ending === "write") {
+          return prec.right(
+            seq(
+              repeat(choice(...steady)),
+              choice(
+                alias($[`_write_flag_${seen}`], $.write_flag),
+                ...transitions,
+              ),
+            ),
+          );
+        }
+        return prec.right(
+          transitions.length === 0
+            ? repeat1(choice(...steady))
+            : choice(
+                repeat1(choice(...steady)),
+                seq(repeat(choice(...steady)), choice(...transitions)),
+              ),
+        );
+      };
+    }
+  }
+  for (const seen of [0, 1, 2, 3]) {
+    rules[`_write_flag_${seen}`] = ($) => {
+      const wfile = field("wfile", alias($._substitution_wfile, $.wfile));
+      return choice(
+        seq(
+          field("verb", alias("w", $.substitution_flag)),
+          choice(
+            ...fileOperandForms($, "wfile", wfile),
+            seq(issueField($, "incomplete_omitted_file_separator"), wfile),
+          ),
+        ),
+        seq(
+          issueField($, "nonfinal_write_flag"),
+          $[`_flags_postwrite_${seen}`],
+          blankSeparatedFileOperand($, "wfile", wfile),
+        ),
+      );
+    };
+  }
+  return rules;
+}
+
 function delimiter($, name) {
   return namedExternal($, $[`_${name}`], "delimiter");
 }
@@ -193,6 +251,7 @@ function delimiter($, name) {
 function missingOpeningDelimiter($) {
   return choice(
     issueField($, "invalid_delimiter"),
+    issueField($, "invalid_encoding"),
     issueField($, "missing_opening_delimiter"),
     issueField($, "nonconforming_missing_opening_delimiter"),
   );
@@ -217,6 +276,21 @@ function semicolonSeparator($) {
   return alias(";", $.command_separator);
 }
 
+function writeCommandUnit($, block = false) {
+  return seq(
+    editingCommand($, "write_terminated"),
+    choice(
+      newlineSeparator($),
+      alias(
+        block ? $._write_block_terminal_separator : $._write_terminal_separator,
+        $.command_separator,
+      ),
+      issueField($, "undefined_write_command_separator"),
+      issueField($, "missing_separator_before_unmatched_brace"),
+    ),
+  );
+}
+
 function commandListRules() {
   return {
     script: ($) => optional(alias($._script_command_list, $.command_list)),
@@ -258,8 +332,7 @@ function commandListRules() {
         repeat(sourcePiece($, $._comment_text, "comment_text")),
       ),
 
-    // Explicit recursion makes cursor traversal quadratic; repeat keeps lists
-    // balanced.
+    // Explicit recursion makes cursor traversal quadratic.
     _command_list: ($) =>
       choice(
         seq(
@@ -272,12 +345,13 @@ function commandListRules() {
 
     _command_unit: ($) =>
       choice(
+        writeCommandUnit($),
         seq(
           $._separable_command_item,
           choice(
             semicolonSeparator($),
             newlineSeparator($),
-            issueNode($, "missing_separator_before_unmatched_brace"),
+            issueField($, "missing_separator_before_unmatched_brace"),
           ),
         ),
         seq(
@@ -285,15 +359,15 @@ function commandListRules() {
           choice(
             semicolonSeparator($),
             newlineSeparator($),
-            issueNode($, "missing_separator_before_unmatched_brace"),
-            issueNode($, "missing_separator_after_unmatched_brace"),
+            issueField($, "missing_separator_before_unmatched_brace"),
+            issueField($, "missing_separator_after_unmatched_brace"),
           ),
         ),
         seq(
           editingCommand($, "line_terminated"),
           choice(
             newlineSeparator($),
-            issueNode($, "missing_separator_before_unmatched_brace"),
+            issueField($, "missing_separator_before_unmatched_brace"),
           ),
         ),
         editingCommand($, "recovered_line_terminated"),
@@ -304,12 +378,13 @@ function commandListRules() {
         $._separable_command_item,
         $._unmatched_closing_brace_item,
         editingCommand($, "line_terminated"),
+        editingCommand($, "write_terminated"),
       ),
 
     _unmatched_closing_brace_item: ($) =>
       seq(
         optional($._brace_leading_blanks),
-        issueNode($, "unmatched_closing_brace"),
+        issueField($, "unmatched_closing_brace"),
         optional($._blanks),
       ),
 
@@ -323,15 +398,13 @@ function commandListRules() {
     _block_commands: ($) =>
       choice(
         repeat1($._block_unit),
-        seq(
-          repeat($._block_unit),
-          optional($._block_item),
-          missingCommandSeparator($),
-        ),
+        seq(repeat($._block_unit), $._block_item, missingCommandSeparator($)),
+        missingCommandSeparator($),
       ),
 
     _block_unit: ($) =>
       choice(
+        writeCommandUnit($, true),
         seq(
           $._separable_command_item,
           choice(semicolonSeparator($), newlineSeparator($)),
@@ -341,7 +414,11 @@ function commandListRules() {
       ),
 
     _block_item: ($) =>
-      choice($._separable_command_item, editingCommand($, "line_terminated")),
+      choice(
+        $._separable_command_item,
+        editingCommand($, "line_terminated"),
+        editingCommand($, "write_terminated"),
+      ),
 
     empty_command: ($) => seq(optional($._blanks), $._empty_command_marker),
 
@@ -513,13 +590,6 @@ function delimitedFunction($, spelling, name, first, middleReason, rest) {
 function operandRules(mode) {
   const expression = mode === "bre" ? "basic_reg_exp" : "extended_reg_exp";
 
-  function substitutionFlagChoice($) {
-    return choice(
-      ...nonWriteSubstitutionFlags($),
-      issueField($, "invalid_substitution_flag"),
-    );
-  }
-
   return {
     substitute_function: ($) =>
       delimitedFunction(
@@ -534,10 +604,7 @@ function operandRules(mode) {
             seq(
               field("closing", delimiter($, "substitute_end")),
               optional(
-                field(
-                  "flags",
-                  alias($._substitution_flags, $.substitution_flags),
-                ),
+                field("flags", alias($._flags_plain_0, $.substitution_flags)),
               ),
             ),
             unterminatedDelimiter($, "replacement"),
@@ -571,30 +638,20 @@ function operandRules(mode) {
 
     escaped_newline: ($) => $._replacement_escaped_newline,
 
-    _substitution_flags: ($) =>
-      prec.right(
-        choice(
-          repeat1(substitutionFlagChoice($)),
-          seq(repeat(substitutionFlagChoice($)), $.write_flag),
-        ),
+    _write_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")),
+        field("flags", alias($._flags_write_0, $.substitution_flags)),
       ),
 
-    occurrence_flag: () => /[0-9]+/,
+    ...substitutionFlagRules(),
 
-    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($)),
-            blankSeparatedFileOperand($, "wfile", wfile),
-          ),
-          ...fileOperandForms($, "wfile", wfile),
-        ),
-      );
-    },
+    occurrence_flag: () => /[0-9]+/,
 
     translate_function: ($) =>
       delimitedFunction(
@@ -673,16 +730,31 @@ function functionRules() {
         $._substitution_wfile_continuation,
       ),
 
-    label: ($) => sourcePieces($, "label_literal", $._line_word),
+    label: ($) =>
+      choice(
+        seq($._label_start, $._label_body),
+        issueField($, "nonportable_label_length"),
+      ),
+
+    _label_body: ($) =>
+      prec.right(
+        repeat1(
+          choice(
+            sourcePiece($, $._label_literal, "label_literal"),
+            issueField($, "nonportable_label_character"),
+          ),
+        ),
+      ),
 
-    comment: ($) => sourcePieces($, "comment_text", $._comment_text),
+    comment: ($) =>
+      prec.right(repeat1(sourcePiece($, $._comment_text, "comment_text"))),
 
     comment_function: ($) =>
       prec.right(
         seq(functionVerb($, "#"), optional(field("comment", $.comment))),
       ),
 
-    closing_brace: ($) => $._right_brace,
+    closing_brace: () => token("}"),
   };
 
   function fileForm(form) {
@@ -747,10 +819,22 @@ function functionRules() {
   return rules;
 }
 
+function commandTail($) {
+  return seq(
+    repeat(issueField($, "invalid_encoding")),
+    optional(
+      choice(
+        issueField($, "unexpected_command_text"),
+        issueField($, "incomplete_command_text"),
+      ),
+    ),
+  );
+}
+
 function unknownFunction($, id) {
   return seq(
-    issueField($, id),
-    optional(issueField($, "unexpected_command_text")),
+    choice(issueField($, id), issueField($, "invalid_encoding")),
+    commandTail($),
   );
 }
 
@@ -761,18 +845,24 @@ function editingCommandRules() {
     2: ($) => $.address_clause,
   };
 
-  // Keep address, issue, and function rules separate by address maximum so
-  // GLR paths cannot merge before the function verb.
+  // Separate address limits to prevent GLR merging before the verb.
   const wrappers = [];
   for (const [kind, isLineTerminated] of [
     ["chainable", false],
     ["line_terminated", true],
+    ["write_terminated", false],
   ]) {
     for (const maximum of [0, 1, 2]) {
       const names = functionDefinitions
         .filter(
-          ({ lineTerminated = false, maxAddresses = 2 }) =>
-            lineTerminated === isLineTerminated && maxAddresses === maximum,
+          ({
+            lineTerminated = false,
+            writeTerminated = false,
+            maxAddresses = 2,
+          }) =>
+            writeTerminated === (kind === "write_terminated") &&
+            lineTerminated === isLineTerminated &&
+            maxAddresses === maximum,
         )
         .map(({ rule }) => rule);
       if (names.length > 0) {
@@ -815,16 +905,13 @@ function editingCommandRules() {
 
   const rules = {
     _chainable_editing_command: ($) =>
-      seq(
-        addressedForms($, "chainable"),
-        optional(issueField($, "unexpected_command_text")),
-      ),
+      seq(addressedForms($, "chainable"), commandTail($)),
+
+    _write_terminated_editing_command: ($) =>
+      seq(addressedForms($, "write_terminated"), commandTail($)),
 
     _line_terminated_editing_command: ($) =>
-      seq(
-        addressedForms($, "line_terminated"),
-        optional(issueField($, "unexpected_command_text")),
-      ),
+      seq(addressedForms($, "line_terminated"), commandTail($)),
 
     _recovered_line_terminated_editing_command: ($) =>
       seq(
@@ -870,7 +957,14 @@ function editingCommandRules() {
   };
 
   for (const { name, names } of wrappers) {
-    rules[name] = ($) => choice(...names.map((name) => $[name]));
+    rules[name] = ($) =>
+      choice(
+        ...names.map((name) =>
+          name === "_write_substitute_function"
+            ? alias($[name], $.substitute_function)
+            : $[name],
+        ),
+      );
   }
 
   return rules;
@@ -910,14 +1004,13 @@ function missingMarkerNames(mode) {
     "omitted_address",
     "incomplete_omitted_address",
     "omitted_first_address",
-    "empty_subexpression",
-    "missing_subexpression",
     ...(mode === "ere" ? ["empty_alternative"] : []),
     "missing_function",
     "missing_label",
     "missing_rfile",
     "missing_wfile",
     "omitted_file_separator",
+    "incomplete_omitted_file_separator",
     "missing_text_introducer",
     "missing_text",
     "missing_command_separator",
@@ -927,7 +1020,6 @@ function missingMarkerNames(mode) {
     "missing_separator_before_unmatched_brace",
     "missing_separator_after_unmatched_brace",
     ...boundaryMissingReasons.map((reason) => `nonconforming_${reason}`),
-    "missing_subexpression_placeholder",
     "incomplete_bracket_list",
     "incomplete_bracket_expression",
     ...(mode === "ere" ? ["incomplete_alternative"] : []),
@@ -942,21 +1034,49 @@ function issueDefinitions(mode) {
 
   return [
     {
-      reason: "malformed_bracket_term",
+      reason: "nonportable_label_character",
+      outcome: "unspecified_syntax",
+      rule: ($) => alias($._nonportable_label_character, $.label_literal),
+    },
+    {
+      reason: "nonportable_label_length",
+      outcome: "unspecified_syntax",
+      rule: ($) =>
+        seq($._long_label_start, alias($._label_literal, $.label_literal)),
+    },
+    {
+      reason: "missing_bracket_term_close",
       outcome: "undefined_syntax",
-      rule: ($) => $._regex_malformed_bracket_term,
+      rule: ($) => $._regex_missing_bracket_term_close,
     },
     {
-      id: "invalid_character_class_name",
-      reason: "malformed_bracket_term",
+      reason: "invalid_character_class_name",
       outcome: "undefined_syntax",
       rule: ($) => $._regex_invalid_class_name,
     },
     {
       id: "equivalence_class_meta_character",
-      reason: "malformed_bracket_term",
+      reason: "invalid_equivalence_class_element",
+      outcome: "undefined_syntax",
+      rule: ($) => namedExternal($, $._regex_meta_char, "meta_character"),
+    },
+    {
+      id: "incomplete_equivalence_class_meta_character",
+      reason: "invalid_equivalence_class_element",
+      outcome: "incomplete_syntax",
+      rule: ($) =>
+        namedExternal($, $._regex_incomplete_meta_char, "meta_character"),
+    },
+    {
+      reason: "missing_bracket_term_payload",
       outcome: "undefined_syntax",
-      rule: ($) => namedExternal($, $._regex_meta_char, "meta_char"),
+      rule: ($) => $._regex_missing_bracket_term_payload,
+    },
+    {
+      id: "incomplete_bracket_term_payload",
+      reason: "missing_bracket_term_payload",
+      outcome: "incomplete_syntax",
+      rule: ($) => $._regex_incomplete_bracket_term_payload,
     },
     {
       reason: "nul_character",
@@ -968,6 +1088,19 @@ function issueDefinitions(mode) {
       outcome: "invalid_syntax",
       rule: ($) => $._nul_character,
     },
+    ...[
+      ["escaped_nul_character", "nul_character", "nonconforming_syntax"],
+      [
+        "escaped_invalid_regular_expression_character",
+        "invalid_regular_expression_character",
+        "invalid_syntax",
+      ],
+    ].map(([id, reason, outcome]) => ({
+      id,
+      reason,
+      outcome,
+      rule: ($) => $._escaped_nul_character,
+    })),
     {
       reason: "invalid_encoding",
       outcome: "invalid_syntax",
@@ -986,8 +1119,7 @@ function issueDefinitions(mode) {
     {
       reason: "shared_range_endpoint",
       outcome: "undefined_syntax",
-      rule: ($) =>
-        namedExternal($, $._regex_shared_range_endpoint, "range_operator"),
+      rule: ($) => alias($._regex_shared_range_endpoint, "-"),
     },
     {
       reason: "omitted_address",
@@ -1017,11 +1149,6 @@ function issueDefinitions(mode) {
       outcome: "undefined_syntax",
       rule: ($) => $._regex_nonportable_escape,
     },
-    {
-      reason: "empty_subexpression",
-      outcome: "undefined_syntax",
-      rule: missing("empty_subexpression"),
-    },
     {
       reason: "unclosed_subexpression",
       outcome: "undefined_syntax",
@@ -1032,39 +1159,61 @@ function issueDefinitions(mode) {
           {
             reason: "unmatched_subexpression_close",
             outcome: "undefined_syntax",
-            rule: ($) =>
-              namedExternal(
-                $,
-                $._regex_unmatched_group_close,
-                "back_close_parenthesis",
-              ),
+            rule: ($) => $._regex_unmatched_group_close,
           },
           {
             reason: "unmatched_interval_close",
             outcome: "undefined_syntax",
-            rule: ($) =>
-              namedExternal(
-                $,
-                $._regex_unmatched_interval_close,
-                "back_close_brace",
-              ),
+            rule: ($) => $._regex_unmatched_interval_close,
           },
         ]
       : []),
     {
-      reason: "malformed_interval",
+      reason: "invalid_interval_character",
+      outcome: "undefined_syntax",
+      rule: ($) => $._regex_invalid_interval,
+    },
+    {
+      reason: "unexpected_interval_separator",
       outcome: "undefined_syntax",
       rule: ($) =>
-        prec.right(
-          repeat1(
-            choice(
-              $._regex_invalid_interval,
-              issueField($, "invalid_regular_expression_character"),
-              issueField($, "invalid_encoding"),
-            ),
+        choice(
+          alias($._regex_interval_separator, ","),
+          namedExternal(
+            $,
+            $._regex_interval_escaped_separator,
+            "escaped_delimiter",
           ),
         ),
     },
+    ...["minimum", "close"].flatMap((part) => [
+      {
+        reason: `missing_interval_${part}`,
+        outcome: "undefined_syntax",
+        rule: ($) => $[`_regex_missing_interval_${part}`],
+      },
+      ...(part === "minimum"
+        ? [
+            {
+              id: "incomplete_interval_minimum",
+              reason: "missing_interval_minimum",
+              outcome: "incomplete_syntax",
+              rule: ($) => $._regex_incomplete_interval_minimum,
+            },
+          ]
+        : []),
+    ]),
+    {
+      reason: "invalid_interval_close",
+      outcome: "undefined_syntax",
+      rule: ($) => $._regex_invalid_interval_close,
+    },
+    {
+      id: "incomplete_interval_close",
+      reason: "invalid_interval_close",
+      outcome: "incomplete_syntax",
+      rule: ($) => $._regex_incomplete_interval_close,
+    },
     {
       reason: "leading_duplication_symbol",
       outcome: "undefined_syntax",
@@ -1114,7 +1263,7 @@ function issueDefinitions(mode) {
       rule: ($) =>
         choice(
           $._translate_nonportable_escape,
-          seq($._escape_prefix, issueField($, "nul_character")),
+          seq($._escape_prefix, issueField($, "escaped_nul_character")),
         ),
     },
     {
@@ -1143,7 +1292,7 @@ function issueDefinitions(mode) {
       rule: ($) =>
         choice(
           $._replacement_nonportable_escape,
-          seq($._escape_prefix, issueField($, "nul_character")),
+          seq($._escape_prefix, issueField($, "escaped_nul_character")),
         ),
     },
     {
@@ -1172,7 +1321,7 @@ function issueDefinitions(mode) {
       rule: ($) =>
         choice(
           $._text_unspecified_escape,
-          seq($._escape_prefix, issueField($, "nul_character")),
+          seq($._escape_prefix, issueField($, "escaped_nul_character")),
         ),
     },
     ...(mode === "bre"
@@ -1180,29 +1329,17 @@ function issueDefinitions(mode) {
           {
             reason: "bre_vertical_line_escape",
             outcome: "implementation_defined_syntax",
-            rule: ($) =>
-              field(
-                "token",
-                namedExternal($, $._regex_bre_vertical_line_escape, "back_bar"),
-              ),
+            rule: ($) => $._regex_bre_vertical_line_escape,
           },
           {
             reason: "bre_question_mark_escape",
             outcome: "implementation_defined_syntax",
-            rule: ($) =>
-              field(
-                "token",
-                namedExternal($, $._regex_bre_question_mark_escape, "back_qm"),
-              ),
+            rule: ($) => $._regex_bre_question_mark_escape,
           },
           {
             reason: "bre_plus_escape",
             outcome: "implementation_defined_syntax",
-            rule: ($) =>
-              field(
-                "token",
-                namedExternal($, $._regex_bre_plus_escape, "back_plus"),
-              ),
+            rule: ($) => $._regex_bre_plus_escape,
           },
           {
             reason: "bre_subexpression_left_anchor",
@@ -1221,6 +1358,12 @@ function issueDefinitions(mode) {
       outcome: "nonconforming_syntax",
       rule: missing("omitted_file_separator"),
     },
+    {
+      id: "incomplete_omitted_file_separator",
+      reason: "omitted_file_separator",
+      outcome: "incomplete_syntax",
+      rule: missing("incomplete_omitted_file_separator"),
+    },
     {
       reason: "excess_address",
       outcome: "nonconforming_syntax",
@@ -1243,11 +1386,7 @@ function issueDefinitions(mode) {
       reason: "unknown_function",
       outcome: "nonconforming_syntax",
       rule: ($) =>
-        choice(
-          token(prec(-2, unknownFunctionCharacter)),
-          $._nul_character,
-          issueField($, "invalid_encoding"),
-        ),
+        choice(token(prec(-2, unknownFunctionCharacter)), $._nul_character),
     },
     {
       id: "reserved_unknown_function",
@@ -1259,11 +1398,14 @@ function issueDefinitions(mode) {
       reason: "unexpected_command_text",
       outcome: "nonconforming_syntax",
       rule: ($) =>
-        repeat1(
-          choice(
-            $._unexpected_command_text,
-            issueField($, "nul_character"),
-            issueField($, "invalid_encoding"),
+        seq(
+          choice($._unexpected_command_text, issueField($, "nul_character")),
+          repeat(
+            choice(
+              $._unexpected_command_text,
+              issueField($, "nul_character"),
+              issueField($, "invalid_encoding"),
+            ),
           ),
         ),
     },
@@ -1272,6 +1414,12 @@ function issueDefinitions(mode) {
       outcome: "nonconforming_syntax",
       rule: ($) => alias(token.immediate(";"), $.command_separator),
     },
+    {
+      id: "incomplete_command_text",
+      reason: "unexpected_command_text",
+      outcome: "incomplete_syntax",
+      rule: ($) => $._incomplete_command_text,
+    },
     {
       reason: "blanks_around_address_separator",
       outcome: "nonconforming_syntax",
@@ -1310,24 +1458,41 @@ function issueDefinitions(mode) {
       rule: missing("missing_separator_after_unmatched_brace"),
     },
     {
-      reason: "invalid_substitution_flag",
-      outcome: "nonconforming_syntax",
+      id: "undefined_write_command_separator",
+      reason: "forbidden_command_separator",
+      outcome: "undefined_syntax",
+      rule: ($) => alias($._write_following_separator, $.command_separator),
+    },
+    {
+      reason: "nonfinal_write_flag",
+      outcome: "undefined_syntax",
       rule: ($) =>
-        choice(
-          $._invalid_substitution_flag,
-          $._nul_character,
-          issueField($, "invalid_encoding"),
+        seq(
+          field("verb", alias("w", $.substitution_flag)),
+          $._flag_after_write_marker,
         ),
     },
+    {
+      id: "conflicting_global_flag",
+      reason: "conflicting_substitution_flag",
+      outcome: "unspecified_syntax",
+      rule: ($) => alias("g", $.global_flag),
+    },
+    {
+      id: "conflicting_occurrence_flag",
+      reason: "conflicting_substitution_flag",
+      outcome: "unspecified_syntax",
+      rule: ($) => $.occurrence_flag,
+    },
+    {
+      reason: "invalid_substitution_flag",
+      outcome: "nonconforming_syntax",
+      rule: ($) => choice($._invalid_substitution_flag, $._nul_character),
+    },
     {
       reason: "invalid_delimiter",
       outcome: "nonconforming_syntax",
-      rule: ($) =>
-        choice(
-          token(/\\/),
-          $._nul_character,
-          issueField($, "invalid_encoding"),
-        ),
+      rule: ($) => choice(token(/\\/), $._nul_character),
     },
     {
       reason: "unterminated_regular_expression",
@@ -1368,11 +1533,6 @@ function issueDefinitions(mode) {
       outcome: "incomplete_syntax",
       rule: rule ?? missing(reason),
     })),
-    {
-      reason: "missing_subexpression",
-      outcome: "incomplete_syntax",
-      rule: missing("missing_subexpression"),
-    },
     {
       id: "incomplete_unclosed_subexpression",
       reason: "unclosed_subexpression",
@@ -1380,7 +1540,8 @@ function issueDefinitions(mode) {
       rule: ($) => $._regex_incomplete_group,
     },
     {
-      reason: "incomplete_bracket_term",
+      id: "incomplete_bracket_term",
+      reason: "missing_bracket_term_close",
       outcome: "incomplete_syntax",
       rule: ($) => $._regex_incomplete_bracket_term,
     },
@@ -1399,14 +1560,16 @@ function issueDefinitions(mode) {
     ...(mode === "ere"
       ? [
           {
-            reason: "incomplete_alternative",
+            id: "incomplete_alternative",
+            reason: "empty_alternative",
             outcome: "incomplete_syntax",
             rule: ($) => $._incomplete_alternative_marker,
           },
         ]
       : []),
     {
-      reason: "incomplete_interval",
+      id: "incomplete_interval",
+      reason: "missing_interval_close",
       outcome: "incomplete_syntax",
       rule: ($) => $._regex_incomplete_interval,
     },
@@ -1417,7 +1580,8 @@ function issueDefinitions(mode) {
       rule: ($) => $._incomplete_command_separator_marker,
     },
     {
-      reason: "incomplete_regular_expression",
+      id: "incomplete_regular_expression",
+      reason: "unterminated_regular_expression",
       outcome: "incomplete_syntax",
       rule: ($) =>
         choice($._regex_unterminated_address, $._regex_unterminated_substitute),
@@ -1428,7 +1592,8 @@ function issueDefinitions(mode) {
       rule: ($) => $._regex_incomplete_escape,
     },
     {
-      reason: "incomplete_replacement",
+      id: "incomplete_replacement",
+      reason: "unterminated_replacement",
       outcome: "incomplete_syntax",
       rule: ($) => $._replacement_unterminated,
     },
@@ -1438,7 +1603,8 @@ function issueDefinitions(mode) {
       rule: ($) => $._replacement_incomplete_escape,
     },
     {
-      reason: "incomplete_translation",
+      id: "incomplete_translation",
+      reason: "unterminated_translation",
       outcome: "incomplete_syntax",
       rule: ($) =>
         choice(
@@ -1468,6 +1634,7 @@ function externalTokens($, mode) {
     $._regex_literal,
     $._invalid_character,
     $._nul_character,
+    $._escaped_nul_character,
     $._regex_beginning_anchor,
     $._regex_end_anchor,
     $._regex_period,
@@ -1503,10 +1670,17 @@ function externalTokens($, mode) {
       : []),
     $._regex_interval_open,
     $._regex_dup_count,
+    $._regex_interval_escaped_count,
+    $._regex_interval_escaped_separator,
     $._regex_interval_separator,
     $._regex_interval_close,
     ...(mode === "bre" ? [$._regex_backreference] : []),
     $._regex_invalid_interval,
+    $._regex_missing_interval_minimum,
+    $._regex_incomplete_interval_minimum,
+    $._regex_missing_interval_close,
+    $._regex_invalid_interval_close,
+    $._regex_incomplete_interval_close,
     $._regex_nonportable_escape,
     $._regex_incomplete_escape,
     $._regex_bracket_open,
@@ -1524,10 +1698,13 @@ function externalTokens($, mode) {
     $._regex_coll_elem_single,
     $._regex_coll_elem_multi,
     $._regex_meta_char,
+    $._regex_incomplete_meta_char,
     $._regex_dot_close,
     $._regex_open_equal,
     $._regex_equal_close,
-    $._regex_malformed_bracket_term,
+    $._regex_missing_bracket_term_close,
+    $._regex_missing_bracket_term_payload,
+    $._regex_incomplete_bracket_term_payload,
     $._regex_shared_range_endpoint,
     $._ambiguous_bracket_expression_marker,
     $._missing_bracket_list_marker,
@@ -1555,6 +1732,9 @@ function externalTokens($, mode) {
     $._translate_unterminated_destination,
     $._invalid_substitution_flag,
     $._flag_after_write_marker,
+    $._write_terminal_separator,
+    $._write_block_terminal_separator,
+    $._write_following_separator,
     $._text_command_start,
     $._text_incomplete_introducer,
     $._text_literal,
@@ -1569,8 +1749,11 @@ function externalTokens($, mode) {
     $._substitution_wfile_argument,
     $._substitution_wfile_continuation,
     $._line_word,
+    $._label_start,
+    $._long_label_start,
+    $._label_literal,
+    $._nonportable_label_character,
     $._argument_separator,
-    $._right_brace,
     $._brace_leading_blanks,
     $._block_trailing_blanks,
     $._empty_command_marker,
@@ -1587,6 +1770,7 @@ function externalTokens($, mode) {
     $._blanks_around_address_separator,
     ...missingMarkerNames(mode).map((name) => $[`_${name}_marker`]),
     $._unexpected_command_text,
+    $._incomplete_command_text,
     $._error_sentinel,
   ];
 }
@@ -1596,7 +1780,7 @@ function defineGrammar(name, mode) {
     throw new Error(`Unsupported regular-expression mode: ${mode}`);
   }
 
-  return grammar({
+  const options = {
     name,
 
     externals: ($) => externalTokens($, mode),
@@ -1618,13 +1802,12 @@ function defineGrammar(name, mode) {
         $._omitted_first_address_unit1_reason,
       ],
     ],
-
-    rules: {
-      ...sedRules(mode),
-      ...regularExpressionRules(mode),
-      ...defineIssueRules(issueDefinitions(mode)),
-    },
-  });
+  };
+  const rules = sedRules(mode);
+  const issues = defineIssueRules(issueDefinitions(mode));
+  return mode === "bre"
+    ? grammar({ ...options, rules: { ...rules, ...breRules(), ...issues } })
+    : grammar({ ...options, rules: { ...rules, ...ereRules(), ...issues } });
 }
 
 export default defineGrammar;