@sshadows/tree-sitter-al 3.2.0 → 3.3.0

package/src/scanner.c

@@ -85,44 +85,24 @@ static bool peek_keyword_ci(TSLexer *lexer, const char *keyword) {
   return true;
 }
 
-// Skip whitespace and any #pragma lines, then peek for a keyword.
-// #pragma lines are transparent extras — we must skip them when scanning ahead
-// for split-construct patterns (e.g., PREPROC_SPLIT_BEGIN checking for #endif).
-static bool peek_keyword_ci_skip_pragma(TSLexer *lexer, const char *keyword) {
+// Directives that grammar.js declares as `extras`. They are transparent to the
+// parse tree, so a lookahead scanning for a structural directive must step over
+// them rather than stop on them. Keep in sync with the `extras` array.
+static const char *const TRANSPARENT_DIRECTIVES[] = {
+  "pragma", "endregion", "region", "define", "undef", NULL,
+};
+
+// Skip whitespace and any transparent-directive lines, then peek for a keyword.
+//
+// Used when scanning ahead for split-construct patterns (e.g.
+// PREPROC_SPLIT_BEGIN checking for #endif). Consuming '#' is irreversible
+// within one scan, so the directive word after '#' is read ONCE into a buffer
+// and then classified — matching candidates one after another would burn the
+// shared prefix of e.g. "endif"/"endregion" on the first failed attempt.
+static bool peek_keyword_ci_skip_extras(TSLexer *lexer, const char *keyword) {
   while (true) {
     skip_whitespace(lexer);
-    // Check for '#pragma' line — skip entire line
-    if (lexer->lookahead == '#') {
-      lexer->advance(lexer, false);
-      // Check if 'pragma' follows
-      const char *pragma = "pragma";
-      bool is_pragma = true;
-      for (int i = 0; pragma[i] != '\0'; i++) {
-        if (towlower(lexer->lookahead) != pragma[i]) { is_pragma = false; break; }
-        lexer->advance(lexer, false);
-      }
-      if (is_pragma && (lexer->lookahead == ' ' || lexer->lookahead == '\t' ||
-                        lexer->lookahead == '\r' || lexer->lookahead == '\n' ||
-                        lexer->lookahead == '\0')) {
-        // Skip rest of this #pragma line
-        while (lexer->lookahead != '\0' && lexer->lookahead != '\n') {
-          lexer->advance(lexer, false);
-        }
-        continue;  // loop back to skip more whitespace/#pragma lines
-      } else {
-        // '#' was followed by something other than 'pragma' — check for keyword
-        // We already consumed '#'; now match rest of keyword (which starts with '#')
-        // Since we consumed '#', match from position 1 of keyword
-        if (keyword[0] != '#') return false;
-        const char *rest = keyword + 1;
-        for (int i = 0; rest[i] != '\0'; i++) {
-          if (towlower(lexer->lookahead) != rest[i]) return false;
-          lexer->advance(lexer, false);
-        }
-        if (is_identifier_char(lexer->lookahead)) return false;
-        return true;
-      }
-    } else {
+    if (lexer->lookahead != '#') {
       // Not '#' — try to match keyword directly
       for (int i = 0; keyword[i] != '\0'; i++) {
         if (towlower(lexer->lookahead) != keyword[i]) return false;
@@ -131,6 +111,38 @@ static bool peek_keyword_ci_skip_pragma(TSLexer *lexer, const char *keyword) {
       if (is_identifier_char(lexer->lookahead)) return false;
       return true;
     }
+
+    lexer->advance(lexer, false);
+    // Horizontal whitespace only: '# pragma' is one directive, but '#' and a
+    // word on the NEXT line are not (matching the extras regexes' `[ \t]*`).
+    while (lexer->lookahead == ' ' || lexer->lookahead == '\t') {
+      lexer->advance(lexer, false);
+    }
+
+    // Read the directive word. Longest AL directive is "endregion" (9).
+    char word[16];
+    size_t len = 0;
+    while (is_identifier_char(lexer->lookahead)) {
+      if (len < sizeof(word) - 1) word[len] = (char)towlower(lexer->lookahead);
+      len++;
+      lexer->advance(lexer, false);
+    }
+    if (len >= sizeof(word)) return false;  // too long to be any directive
+    word[len] = '\0';
+
+    // The caller's keyword includes the '#' we just consumed.
+    if (keyword[0] == '#' && strcmp(word, keyword + 1) == 0) return true;
+
+    bool transparent = false;
+    for (int i = 0; TRANSPARENT_DIRECTIVES[i] != NULL; i++) {
+      if (strcmp(word, TRANSPARENT_DIRECTIVES[i]) == 0) { transparent = true; break; }
+    }
+    if (!transparent) return false;
+
+    // Skip the rest of this directive's line, then look again.
+    while (lexer->lookahead != '\0' && lexer->lookahead != '\n') {
+      lexer->advance(lexer, false);
+    }
   }
 }
 
@@ -223,12 +235,13 @@ bool tree_sitter_al_external_scanner_scan(
   // including '#'). PREPROC_OPEN/CLOSE manually advance past '#' before calling
   // read_keyword_ci("if"/"endif"). These are DIFFERENT conventions — do not mix.
   //
-  // #pragma lines are transparent extras — we skip them when scanning ahead for #endif.
+  // #pragma/#region/#define and friends are transparent extras — we skip them
+  // when scanning ahead for #endif (see TRANSPARENT_DIRECTIVES).
   if (valid_symbols[PREPROC_SPLIT_BEGIN] && state->depth > 0) {
     skip_whitespace(lexer);
     if (read_keyword_ci(lexer, "begin")) {
       lexer->mark_end(lexer);  // token covers only 'begin'
-      if (peek_keyword_ci_skip_pragma(lexer, "#endif")) {
+      if (peek_keyword_ci_skip_extras(lexer, "#endif")) {
         lexer->result_symbol = PREPROC_SPLIT_BEGIN;
         return true;
       }

package/src/tree_sitter/array.h

@@ -50,12 +50,18 @@ extern "C" {
 /// memory allocated for the array's contents.
 #define array_clear(self) ((self)->size = 0)
 
+#ifdef __cplusplus
+#define _array__cast(self, expr) (decltype((self)->contents))(expr)
+#else
+#define _array__cast(self, expr) (expr)
+#endif
+
 /// Reserve `new_capacity` elements of space in the array. If `new_capacity` is
 /// less than the array's current capacity, this function has no effect.
-#define array_reserve(self, new_capacity)        \
-  ((self)->contents = _array__reserve(           \
-    (void *)(self)->contents, &(self)->capacity, \
-    array_elem_size(self), new_capacity)         \
+#define array_reserve(self, new_capacity)                 \
+  ((self)->contents = _array__cast(self, _array__reserve( \
+    (void *)(self)->contents, &(self)->capacity,          \
+    array_elem_size(self), new_capacity))                 \
   )
 
 /// Free any memory allocated for this array. Note that this does not free any
@@ -71,10 +77,10 @@ extern "C" {
 /// Push a new `element` onto the end of the array.
 #define array_push(self, element)                                 \
   do {                                                            \
-    (self)->contents = _array__grow(                              \
+    (self)->contents = _array__cast(self, _array__grow(           \
       (void *)(self)->contents, (self)->size, &(self)->capacity,  \
       1, array_elem_size(self)                                    \
-    );                                                            \
+    ));                                                           \
    (self)->contents[(self)->size++] = (element);                  \
   } while(0)
 
@@ -83,10 +89,10 @@ extern "C" {
 #define array_grow_by(self, count)                                               \
   do {                                                                           \
     if ((count) == 0) break;                                                     \
-    (self)->contents = _array__grow(                                             \
+    (self)->contents = _array__cast(self, _array__grow(                          \
       (self)->contents, (self)->size, &(self)->capacity,                         \
       count, array_elem_size(self)                                               \
-    );                                                                           \
+    ));                                                                          \
     memset((self)->contents + (self)->size, 0, (count) * array_elem_size(self)); \
     (self)->size += (count);                                                     \
   } while (0)
@@ -98,26 +104,26 @@ extern "C" {
 /// Append `count` elements to the end of the array, reading their values from the
 /// `contents` pointer.
 #define array_extend(self, count, other_contents)                 \
-  (self)->contents = _array__splice(                              \
+  ((self)->contents = _array__cast(self, _array__splice(          \
     (void*)(self)->contents, &(self)->size, &(self)->capacity,    \
     array_elem_size(self), (self)->size, 0, count, other_contents \
-  )
+  )))
 
 /// Remove `old_count` elements from the array starting at the given `index`. At
 /// the same index, insert `new_count` new elements, reading their values from the
 /// `new_contents` pointer.
 #define array_splice(self, _index, old_count, new_count, new_contents) \
-  (self)->contents = _array__splice(                                   \
+  ((self)->contents = _array__cast(self, _array__splice(              \
     (void *)(self)->contents, &(self)->size, &(self)->capacity,        \
     array_elem_size(self), _index, old_count, new_count, new_contents  \
-  )
+  )))
 
 /// Insert one `element` into the array at the given `index`.
 #define array_insert(self, _index, element)                     \
-  (self)->contents = _array__splice(                            \
+  ((self)->contents = _array__cast(self, _array__splice(        \
     (void *)(self)->contents, &(self)->size, &(self)->capacity, \
     array_elem_size(self), _index, 0, 1, &(element)             \
-  )
+  )))
 
 /// Remove one element from the array at the given `index`.
 #define array_erase(self, _index) \
@@ -128,17 +134,17 @@ extern "C" {
 
 /// Assign the contents of one array to another, reallocating if necessary.
 #define array_assign(self, other)                                   \
-  (self)->contents = _array__assign(                                \
+  ((self)->contents = _array__cast(self, _array__assign(            \
     (void *)(self)->contents, &(self)->size, &(self)->capacity,     \
     (const void *)(other)->contents, (other)->size, array_elem_size(self) \
-  )
+  )))
 
 /// Swap one array with another
 #define array_swap(self, other)                                     \
   do {                                                              \
     void *_array_swap_tmp = (void *)(self)->contents;               \
     (self)->contents = (other)->contents;                           \
-    (other)->contents = _array_swap_tmp;                            \
+    (other)->contents = _array__cast(other, _array_swap_tmp);       \
     _array__swap(&(self)->size, &(self)->capacity,                  \
                  &(other)->size, &(other)->capacity);               \
   } while (0)

package/queries/bad_delete.scm.v1

@@ -1,30 +0,0 @@
-; ── "OnBeforeDeleteEvent subscribers missing IsTemporary guard" ─────────────────────────────
-(
-  ; The attribute_item and procedure must be adjacent siblings (Rust-style attributes)
-  (attribute_item
-    attribute: (attribute_content
-      name: (identifier) @attr_name
-      arguments: (attribute_arguments
-        arguments: (expression_list
-          (qualified_enum_value)               ; ObjectType::Table
-          [(integer) (database_reference)]     ; Table ID or Database::"Table Name"
-          [(string_literal) (identifier)] @event_name ; Event name (with or without quotes)
-          (string_literal)                     ; Publisher object
-          (boolean)                            ; Publisher function
-          (boolean)))))                        ; Skip on missing
-  .                                            ; Adjacent sibling operator
-  (procedure
-    name: (name) @proc_name
-    (parameter_list
-      (parameter
-        parameter_name: (name) @rec_param)     ; var Rec: Record
-      (parameter
-        parameter_name: (name)))               ; RunTrigger: Boolean
-    (var_section)?                             ; Optional var section
-    (code_block                                ; BEGIN … END;
-      (_) @first_statement                     ; Capture first statement (any type)
-      .))                                      ; Ensure it's the first
-  (#eq? @attr_name "EventSubscriber")          ; Match EventSubscriber attribute
-  (#match? @event_name "OnBeforeDeleteEvent")  ; Match OnBeforeDeleteEvent (with or without quotes)
-  (#not-match? @first_statement "IsTemporary"); First statement does NOT contain IsTemporary
-)