tree-sitter-sed 0.13.0 → 0.14.0

package/Cargo.toml

@@ -10,7 +10,7 @@ name = "tree-sitter-sed"
 publish = false
 readme = "README.md"
 repository = "https://github.com/konomanoasa/tree-sitter-sed"
-version = "0.13.0"
+version = "0.14.0"
 
 build = "bindings/rust/build.rs"
 include = [

package/common/grammar.js

@@ -935,6 +935,25 @@ function sedRules(mode) {
   };
 }
 
+const missingCommandDefinitions = [
+  { reason: "missing_function", atBoundary: true },
+  { reason: "missing_label", atBoundary: true },
+  { reason: "missing_rfile", atBoundary: true },
+  { reason: "missing_wfile", atBoundary: true },
+  { reason: "missing_text_introducer", atBoundary: true },
+  {
+    reason: "incomplete_text_introducer",
+    rule: ($) => $._text_incomplete_introducer,
+  },
+  { reason: "missing_text" },
+  { reason: "missing_closing_brace" },
+  { reason: "missing_opening_delimiter", atBoundary: true },
+];
+
+const boundaryMissingReasons = missingCommandDefinitions
+  .filter(({ atBoundary }) => atBoundary)
+  .map(({ reason }) => reason);
+
 function missingMarkerNames(mode) {
   return [
     "omitted_address",
@@ -956,12 +975,7 @@ function missingMarkerNames(mode) {
     "missing_opening_delimiter",
     "missing_separator_before_unmatched_brace",
     "missing_separator_after_unmatched_brace",
-    "nonconforming_missing_function",
-    "nonconforming_missing_label",
-    "nonconforming_missing_rfile",
-    "nonconforming_missing_wfile",
-    "nonconforming_missing_text_introducer",
-    "nonconforming_missing_opening_delimiter",
+    ...boundaryMissingReasons.map((reason) => `nonconforming_${reason}`),
     "missing_subexpression_placeholder",
     "incomplete_bracket_list",
     "incomplete_bracket_expression",
@@ -975,15 +989,6 @@ function issueDefinitions(mode) {
     return ($) => $[`_${reason}_marker`];
   }
 
-  const boundaryMissingReasons = [
-    "missing_function",
-    "missing_label",
-    "missing_rfile",
-    "missing_wfile",
-    "missing_text_introducer",
-    "missing_opening_delimiter",
-  ];
-
   return [
     {
       reason: "malformed_bracket_term",
@@ -1403,51 +1408,11 @@ function issueDefinitions(mode) {
       outcome: "nonconforming_syntax",
       rule: missing(`nonconforming_${reason}`),
     })),
-    {
-      reason: "missing_function",
-      outcome: "incomplete_syntax",
-      rule: missing("missing_function"),
-    },
-    {
-      reason: "missing_label",
-      outcome: "incomplete_syntax",
-      rule: missing("missing_label"),
-    },
-    {
-      reason: "missing_rfile",
-      outcome: "incomplete_syntax",
-      rule: missing("missing_rfile"),
-    },
-    {
-      reason: "missing_wfile",
-      outcome: "incomplete_syntax",
-      rule: missing("missing_wfile"),
-    },
-    {
-      reason: "missing_text_introducer",
-      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",
-      rule: missing("missing_text"),
-    },
-    {
-      reason: "missing_closing_brace",
-      outcome: "incomplete_syntax",
-      rule: missing("missing_closing_brace"),
-    },
-    {
-      reason: "missing_opening_delimiter",
+    ...missingCommandDefinitions.map(({ reason, rule }) => ({
+      reason,
       outcome: "incomplete_syntax",
-      rule: missing("missing_opening_delimiter"),
-    },
+      rule: rule ?? missing(reason),
+    })),
     {
       reason: "missing_subexpression",
       outcome: "incomplete_syntax",

package/common/regex.js

@@ -316,6 +316,20 @@ function regularExpressionEscape($) {
   );
 }
 
+function oneCharOrCollElem($, ...additional) {
+  return choice(
+    issueField($, "invalid_regular_expression_character"),
+    issueField($, "invalid_encoding"),
+    $.ordinary_character,
+    regularExpressionEscape($),
+    $.sed_newline_escape,
+    $.period,
+    $._bracket_expression,
+    issueField($, "special_delimiter_escape"),
+    ...additional,
+  );
+}
+
 function commonRegularExpressionRules() {
   return {
     dup_count: ($) => $._regex_dup_count,
@@ -432,15 +446,8 @@ function breRules() {
     backreference: ($) => $._regex_backreference,
 
     one_char_or_coll_elem_bre: ($) =>
-      choice(
-        issueField($, "invalid_regular_expression_character"),
-        issueField($, "invalid_encoding"),
-        $.ordinary_character,
-        regularExpressionEscape($),
-        $.sed_newline_escape,
-        $.period,
-        $._bracket_expression,
-        issueField($, "special_delimiter_escape"),
+      oneCharOrCollElem(
+        $,
         issueField($, "bre_vertical_line_escape"),
         issueField($, "bre_question_mark_escape"),
         issueField($, "bre_plus_escape"),
@@ -524,17 +531,7 @@ function ereRules() {
         field("operator", issueNode($, "leading_duplication_symbol")),
       ),
 
-    one_char_or_coll_elem_ere: ($) =>
-      choice(
-        issueField($, "invalid_regular_expression_character"),
-        issueField($, "invalid_encoding"),
-        $.ordinary_character,
-        regularExpressionEscape($),
-        $.sed_newline_escape,
-        $.period,
-        $._bracket_expression,
-        issueField($, "special_delimiter_escape"),
-      ),
+    one_char_or_coll_elem_ere: ($) => oneCharOrCollElem($),
 
     ere_dupl_symbol: ($) =>
       seq(

package/common/scanner.h

@@ -2339,6 +2339,129 @@ scan_right_brace(TSLexer *lexer, const bool *valid_symbols, TSSymbol *symbol) {
   return false;
 }
 
+static bool scan_command_recovery(
+  TSLexer *lexer,
+  const bool *valid_symbols,
+  TSSymbol *symbol
+) {
+  if (
+    lexer->lookahead ==
+    ',' &&
+    emit_marker(lexer, valid_symbols, OMITTED_FIRST_ADDRESS_MARKER, symbol)
+  ) {
+    return true;
+  }
+
+  if (
+    (valid_symbols[OMITTED_ADDRESS_MARKER] ||
+      valid_symbols[INCOMPLETE_OMITTED_ADDRESS_MARKER]) &&
+    !can_start_address(lexer) &&
+    !is_blank(lexer->lookahead)
+  ) {
+    return emit_marker(
+      lexer,
+      valid_symbols,
+      lexer->eof(lexer) ? INCOMPLETE_OMITTED_ADDRESS_MARKER
+                        : OMITTED_ADDRESS_MARKER,
+      symbol
+    );
+  }
+
+  if (is_blank(lexer->lookahead)) {
+    switch (scan_post_blank_recovery(lexer, valid_symbols, symbol)) {
+    case POST_BLANK_RECOVERY_TOKEN:
+      return true;
+    case POST_BLANK_RECOVERY_FAILED:
+      return scan_unexpected_command_text(lexer, valid_symbols, symbol, true);
+    case POST_BLANK_RECOVERY_SKIPPED:
+      break;
+    }
+  }
+
+  if (
+    !at_command_boundary(lexer) &&
+    !is_blank(lexer->lookahead) &&
+    emit_marker(lexer, valid_symbols, OMITTED_FILE_SEPARATOR_MARKER, symbol)
+  ) {
+    return true;
+  }
+
+  if (at_command_boundary(lexer)) {
+    static const TSSymbol boundary_markers[][2] = {
+      {MISSING_FUNCTION_MARKER, NONCONFORMING_MISSING_FUNCTION_MARKER},
+      {MISSING_LABEL_MARKER, NONCONFORMING_MISSING_LABEL_MARKER},
+      {MISSING_RFILE_MARKER, NONCONFORMING_MISSING_RFILE_MARKER},
+      {MISSING_WFILE_MARKER, NONCONFORMING_MISSING_WFILE_MARKER},
+    };
+    const unsigned variant = lexer->eof(lexer) ? 0 : 1;
+    for (
+      unsigned index = 0;
+      index < sizeof(boundary_markers) / sizeof(boundary_markers[0]);
+      index++
+    ) {
+      if (
+        emit_marker(
+          lexer,
+          valid_symbols,
+          boundary_markers[index][variant],
+          symbol
+        )
+      ) {
+        return true;
+      }
+    }
+  }
+
+  if (
+    emit_marker(
+      lexer,
+      valid_symbols,
+      missing_text_introducer_symbol(lexer),
+      symbol
+    )
+  ) {
+    return true;
+  }
+
+  if (
+    lexer->eof(lexer) &&
+    emit_marker(lexer, valid_symbols, MISSING_CLOSING_BRACE_MARKER, symbol)
+  ) {
+    return true;
+  }
+
+  if (
+    !at_command_boundary(lexer) &&
+    !is_blank(lexer->lookahead) &&
+    emit_marker(
+      lexer,
+      valid_symbols,
+      MISSING_SEPARATOR_AFTER_UNMATCHED_BRACE_MARKER,
+      symbol
+    )
+  ) {
+    return true;
+  }
+
+  const TSSymbol separator_marker =
+    missing_command_separator_marker(lexer, valid_symbols);
+  if (separator_marker != ERROR_SENTINEL) {
+    return emit_marker(lexer, valid_symbols, separator_marker, symbol);
+  }
+
+  const TSSymbol missing_opening_delimiter = lexer->eof(lexer)
+    ? MISSING_OPENING_DELIMITER_MARKER
+    : NONCONFORMING_MISSING_OPENING_DELIMITER_MARKER;
+  if (
+    delimiter_is_missing(lexer) &&
+    emit_marker(lexer, valid_symbols, missing_opening_delimiter, symbol)
+  ) {
+    return true;
+  }
+
+  return scan_unexpected_command_text(lexer, valid_symbols, symbol, false);
+}
+
 static bool scan_command_token(
   TSLexer *lexer,
   ScannerState *state,
@@ -2512,122 +2635,7 @@ static bool scan_command_token(
     return scan_right_brace(lexer, valid_symbols, symbol);
   }
 
-  if (
-    lexer->lookahead ==
-    ',' &&
-    emit_marker(lexer, valid_symbols, OMITTED_FIRST_ADDRESS_MARKER, symbol)
-  ) {
-    return true;
-  }
-
-  if (
-    (valid_symbols[OMITTED_ADDRESS_MARKER] ||
-      valid_symbols[INCOMPLETE_OMITTED_ADDRESS_MARKER]) &&
-    !can_start_address(lexer) &&
-    !is_blank(lexer->lookahead)
-  ) {
-    return emit_marker(
-      lexer,
-      valid_symbols,
-      lexer->eof(lexer) ? INCOMPLETE_OMITTED_ADDRESS_MARKER
-                        : OMITTED_ADDRESS_MARKER,
-      symbol
-    );
-  }
-
-  if (is_blank(lexer->lookahead)) {
-    switch (scan_post_blank_recovery(lexer, valid_symbols, symbol)) {
-    case POST_BLANK_RECOVERY_TOKEN:
-      return true;
-    case POST_BLANK_RECOVERY_FAILED:
-      return scan_unexpected_command_text(lexer, valid_symbols, symbol, true);
-    case POST_BLANK_RECOVERY_SKIPPED:
-      break;
-    }
-  }
-
-  if (
-    !at_command_boundary(lexer) &&
-    !is_blank(lexer->lookahead) &&
-    emit_marker(lexer, valid_symbols, OMITTED_FILE_SEPARATOR_MARKER, symbol)
-  ) {
-    return true;
-  }
-
-  if (at_command_boundary(lexer)) {
-    static const TSSymbol boundary_markers[][2] = {
-      {MISSING_FUNCTION_MARKER, NONCONFORMING_MISSING_FUNCTION_MARKER},
-      {MISSING_LABEL_MARKER, NONCONFORMING_MISSING_LABEL_MARKER},
-      {MISSING_RFILE_MARKER, NONCONFORMING_MISSING_RFILE_MARKER},
-      {MISSING_WFILE_MARKER, NONCONFORMING_MISSING_WFILE_MARKER},
-    };
-    const unsigned variant = lexer->eof(lexer) ? 0 : 1;
-    for (
-      unsigned index = 0;
-      index < sizeof(boundary_markers) / sizeof(boundary_markers[0]);
-      index++
-    ) {
-      if (
-        emit_marker(
-          lexer,
-          valid_symbols,
-          boundary_markers[index][variant],
-          symbol
-        )
-      ) {
-        return true;
-      }
-    }
-  }
-
-  if (
-    emit_marker(
-      lexer,
-      valid_symbols,
-      missing_text_introducer_symbol(lexer),
-      symbol
-    )
-  ) {
-    return true;
-  }
-
-  if (
-    lexer->eof(lexer) &&
-    emit_marker(lexer, valid_symbols, MISSING_CLOSING_BRACE_MARKER, symbol)
-  ) {
-    return true;
-  }
-
-  if (
-    !at_command_boundary(lexer) &&
-    !is_blank(lexer->lookahead) &&
-    emit_marker(
-      lexer,
-      valid_symbols,
-      MISSING_SEPARATOR_AFTER_UNMATCHED_BRACE_MARKER,
-      symbol
-    )
-  ) {
-    return true;
-  }
-
-  const TSSymbol separator_marker =
-    missing_command_separator_marker(lexer, valid_symbols);
-  if (separator_marker != ERROR_SENTINEL) {
-    return emit_marker(lexer, valid_symbols, separator_marker, symbol);
-  }
-
-  const TSSymbol missing_opening_delimiter = lexer->eof(lexer)
-    ? MISSING_OPENING_DELIMITER_MARKER
-    : NONCONFORMING_MISSING_OPENING_DELIMITER_MARKER;
-  if (
-    delimiter_is_missing(lexer) &&
-    emit_marker(lexer, valid_symbols, missing_opening_delimiter, symbol)
-  ) {
-    return true;
-  }
-
-  return scan_unexpected_command_text(lexer, valid_symbols, symbol, false);
+  return scan_command_recovery(lexer, valid_symbols, symbol);
 }
 
 static bool sed_scanner_scan_impl(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tree-sitter-sed",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "type": "module",
   "description": "Tree-sitter grammars for POSIX sed.",
   "license": "MIT",

package/sed_ere/src/parser.c

@@ -56370,7 +56370,7 @@ TS_PUBLIC const TSLanguage *tree_sitter_sed_ere(void) {
     .max_reserved_word_set_size = 0,
     .metadata = {
       .major_version = 0,
-      .minor_version = 13,
+      .minor_version = 14,
       .patch_version = 0,
     },
   };

package/src/parser.c

@@ -59264,7 +59264,7 @@ TS_PUBLIC const TSLanguage *tree_sitter_sed(void) {
     .max_reserved_word_set_size = 0,
     .metadata = {
       .major_version = 0,
-      .minor_version = 13,
+      .minor_version = 14,
       .patch_version = 0,
     },
   };

package/tree-sitter.json

@@ -21,7 +21,7 @@
     }
   ],
   "metadata": {
-    "version": "0.13.0",
+    "version": "0.14.0",
     "license": "MIT",
     "description": "Tree-sitter grammars for POSIX sed.",
     "authors": [