@dekobon/tree-sitter-groovy 0.4.0 → 0.5.0

package/src/scanner.c

@@ -1,8 +1,11 @@
 // Hand-written external scanner for tree-sitter-groovy.
 //
-// Handles §6.2 slashy-string-start and §6.6 line/block/groovydoc
-// comments. Both start with `/`; combining the dispatch keeps the
-// in-grammar lexer from partially consuming the leading `/`.
+// Handles §6.2 slashy-string-start, §6.6 line/block/groovydoc
+// comments, and the §6.7 contextual `record` keyword. The first two
+// start with `/`; combining their dispatch keeps the in-grammar lexer
+// from partially consuming the leading `/`. The third is a look-ahead
+// decision the grammar cannot express: `record` is a keyword only
+// when a record header follows it.
 //
 // Stateless — `create` returns NULL and the runtime calls
 // `destroy` / `serialize` / `deserialize` as no-ops. When a future
@@ -15,6 +18,7 @@ enum TokenType {
     LINE_COMMENT,
     BLOCK_COMMENT,
     GROOVYDOC_COMMENT,
+    RECORD_KEYWORD,
 };
 
 static inline void advance(TSLexer *lexer) {
@@ -25,6 +29,112 @@ static inline bool is_whitespace(int32_t c) {
     return c == ' ' || c == '\t' || c == '\n' || c == '\r';
 }
 
+static inline bool is_inline_space(int32_t c) {
+    return c == ' ' || c == '\t';
+}
+
+// Mirrors the grammar's `identifier` token, /[A-Za-z_$][A-Za-z0-9_$]*/.
+static inline bool is_identifier_start(int32_t c) {
+    return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')
+        || c == '_' || c == '$';
+}
+
+static inline bool is_identifier_char(int32_t c) {
+    return is_identifier_start(c) || (c >= '0' && c <= '9');
+}
+
+// Skips the trivia Groovy's lexer hides inside a record header:
+// spaces, tabs and block comments, plus line breaks and line comments
+// when `newlines` is set. Returns false on a `/` that opens neither
+// comment kind (a slashy string or division cannot be part of a
+// header) and on an unterminated block comment.
+static bool skip_header_trivia(TSLexer *lexer, bool newlines) {
+    for (;;) {
+        while (is_inline_space(lexer->lookahead)
+            || (newlines
+                && (lexer->lookahead == '\n' || lexer->lookahead == '\r'))) {
+            advance(lexer);
+        }
+        if (lexer->lookahead != '/') {
+            return true;
+        }
+        advance(lexer);
+        if (lexer->lookahead == '*') {
+            advance(lexer);
+            // EOF-bounded: an unterminated comment ends the scan here.
+            for (;;) {
+                if (lexer->eof(lexer)) {
+                    return false;
+                }
+                if (lexer->lookahead == '*') {
+                    advance(lexer);
+                    if (lexer->lookahead == '/') {
+                        advance(lexer);
+                        break;
+                    }
+                } else {
+                    advance(lexer);
+                }
+            }
+        } else if (newlines && lexer->lookahead == '/') {
+            while (!lexer->eof(lexer) && lexer->lookahead != '\n') {
+                advance(lexer);
+            }
+        } else {
+            return false;
+        }
+    }
+}
+
+// SPECIFICATION.md §6.7 — `record` is a keyword only at the start of
+// a record header: `record`, a name on the same line, then `(` with
+// Groovy's lexer trivia allowed in between, or `<` straight after the
+// name (type parameters; the grammar's `type_parameters` opener is
+// `token.immediate` too). Everywhere else the word
+// is an identifier (`record.key()`, `private Record record`,
+// `public void record()`), as Apache's `identifier` rule allows. The
+// grammar cannot make that choice: with `word: $.identifier` the
+// keyword wins wherever it has an action, and once
+// record_declaration is a class member that is every member start.
+//
+// The scanner has already consumed `record` when this is called.
+// `mark_end` fixes the token there; the look-ahead that follows is
+// read but not kept. Between `record` and the name only spaces, tabs
+// and block comments may appear: `classDeclaration` in
+// GroovyParser.g4 has no `nls` there, so `record` at the end of a line
+// is never a keyword, which keeps `private Record record` followed by
+// a constructor on the next line a field and a constructor. Before
+// `(` the rule has `nls`, so line breaks and line comments are
+// skipped there too. A command-style call `record Point(1, 2)`
+// matches the pattern and misfires; §6.7 lists the residuals.
+static bool scan_record_header(TSLexer *lexer) {
+    if (is_identifier_char(lexer->lookahead)) {
+        return false;
+    }
+    lexer->mark_end(lexer);
+    if (!is_inline_space(lexer->lookahead) && lexer->lookahead != '/') {
+        return false;
+    }
+    if (!skip_header_trivia(lexer, false)) {
+        return false;
+    }
+    if (!is_identifier_start(lexer->lookahead)) {
+        return false;
+    }
+    // EOF-bounded: lookahead is 0 at end of input, which fails the
+    // predicate.
+    while (is_identifier_char(lexer->lookahead)) {
+        advance(lexer);
+    }
+    if (lexer->lookahead == '<') {
+        return true;
+    }
+    if (!skip_header_trivia(lexer, true)) {
+        return false;
+    }
+    return lexer->lookahead == '(';
+}
+
 void *tree_sitter_groovy_external_scanner_create(void) {
     return NULL;
 }
@@ -67,18 +177,38 @@ bool tree_sitter_groovy_external_scanner_scan(
     // in-grammar `\s` SKIP rule — without this, tree-sitter's lexer
     // eats `\n`, does NOT re-invoke the external scanner, then
     // fails on the following `/` and consumes it through error
-    // recovery.
+    // recovery. §6.7 `record` shares the whitespace skip and is
+    // dispatched on `r` before the `/` branches.
     bool wants_comment = valid_symbols[LINE_COMMENT]
         || valid_symbols[BLOCK_COMMENT]
         || valid_symbols[GROOVYDOC_COMMENT];
     bool wants_slashy = valid_symbols[SLASHY_STRING_START];
-    if (!wants_comment && !wants_slashy) {
+    bool wants_record = valid_symbols[RECORD_KEYWORD];
+    if (!wants_comment && !wants_slashy && !wants_record) {
         return false;
     }
 
     while (is_whitespace(lexer->lookahead)) {
         lexer->advance(lexer, true);
     }
+    if (lexer->lookahead == 'r' && wants_record) {
+        // An `r` can never open a comment or a slashy string, so
+        // every path out of this branch returns. On `false` the
+        // runtime rewinds to the token start and the in-grammar
+        // lexer reads the word as an identifier.
+        static const char keyword[] = "record";
+        for (const char *c = keyword; *c != '\0'; c++) {
+            if (lexer->lookahead != *c) {
+                return false;
+            }
+            advance(lexer);
+        }
+        if (!scan_record_header(lexer)) {
+            return false;
+        }
+        lexer->result_symbol = RECORD_KEYWORD;
+        return true;
+    }
     if (lexer->lookahead != '/') {
         return false;
     }

package/tree-sitter.json

@@ -13,7 +13,7 @@
     }
   ],
   "metadata": {
-    "version": "0.4.0",
+    "version": "0.5.0",
     "license": "Apache-2.0 OR MIT",
     "description": "Apache Groovy grammar for tree-sitter (dekobon fork)",
     "authors": [