tree-sitter-ucode 0.1.0 → 0.2.0

package/README.md

@@ -17,13 +17,12 @@ Ucode is an ECMAScript subset with OpenWrt-specific extensions. Key differences:
 |---------|-------|------------|
 | Alternative block syntax | `if/elif/else/endif`, `for/endfor`, `while/endwhile`, `function/endfunction` | Not supported |
 | Two-variable for-in | `for (k, v in obj)` | Single variable only |
-| Forward declaration | `function foo;` | Not supported |
-| Removed keywords | `var`, `new`, `typeof`, `void`, `class`, `instanceof`, `do`, `async`, `await`, `yield` | All supported |
-| Removed features | Destructuring, `for...of`, `do-while`, generators | All supported |
+| Removed keywords | `var`, `new`, `throw`, `typeof`, `void`, `class`, `instanceof`, `do`, `async`, `await`, `yield` | All supported |
+| Removed features | Destructuring, `for...of`, `do-while`, generators, forward declarations, dynamic `import()` | All supported |
 | Added number literals | `0177` (C octal), `0x1.8` (hex float), `0B`/`0O` prefixes | Standard only |
 | Added escape sequences | `\e` (ESC), `\a` (BEL), octal `\177` | Standard only |
 | Regex flags | `g`, `i`, `s` only | Full set |
-| Module system | Static `import`/`export`, dynamic `import(path)`; no `from` on re-exports | Full ES modules |
+| Module system | Static `import`/`export` only; no `from` on re-exports | Full ES modules |
 
 ## Requirements
 

package/grammar.js

@@ -4,7 +4,7 @@
  *
  * Based on tree-sitter-javascript (MIT, Max Brunsfeld, Amaan Qureshi).
  * Ucode is an ECMAScript-like language for OpenWrt system scripting.
- * See linter/diff-to-js.md for a full list of syntax differences from JS.
+ * See README.md for a full list of syntax differences from JavaScript.
  */
 
 /// <reference types="tree-sitter-cli/dsl" />
@@ -46,6 +46,7 @@ module.exports = grammar({
       'if',
       'import',
       'in',
+      'let',
       'null',
       'return',
       'switch',
@@ -54,7 +55,7 @@ module.exports = grammar({
       'try',
       'while',
     ],
-    properties: $ => [],
+    properties: _ => [],
   },
 
   supertypes: $ => [
@@ -84,7 +85,6 @@ module.exports = grammar({
       'binary_times',
       'binary_plus',
       'binary_shift',
-      'binary_compare',
       'binary_relation',
       'binary_equality',
       'bitwise_and',
@@ -100,22 +100,16 @@ module.exports = grammar({
     ['member', 'call', $.expression],
     ['declaration', 'literal'],
     [$.primary_expression, $.statement_block, 'object'],
-    [$.import_statement, $.import],
     [$.export_statement, $.primary_expression],
     [$.lexical_declaration, $.primary_expression],
   ],
 
   conflicts: $ => [
-    [$.primary_expression, $._property_name],
-    [$.primary_expression, $.arrow_function],
-    [$.primary_expression, $.arrow_function, $._property_name],
     [$.primary_expression, $.formal_parameters],
     [$.primary_expression, $._for_header],
     [$.variable_declarator, $._for_header],
     [$.assignment_expression, $.pattern],
     [$.labeled_statement, $._property_name],
-    [$.computed_property_name, $.array],
-    [$.binary_expression, $._initializer],
   ],
 
   word: $ => $.identifier,
@@ -149,7 +143,7 @@ module.exports = grammar({
             'default',
             seq(
               field('value', $.expression),
-              $._semicolon,
+              ';',
             ),
           ),
         ),
@@ -179,18 +173,14 @@ module.exports = grammar({
 
     declaration: $ => choice(
       $.function_declaration,
-      $.function_forward_declaration,
       $.lexical_declaration,
     ),
 
     //
     // Import declarations
     // Ucode keeps full ES module static import syntax.
-    // Also adds dynamic `import(path)` as a unary expression (see import_expression).
     //
 
-    import: _ => token('import'),
-
     import_statement: $ => seq(
       'import',
       choice(
@@ -325,36 +315,12 @@ module.exports = grammar({
     ),
 
     for_statement: $ => seq(
-      'for',
-      '(',
-      choice(
-        field('initializer', $.lexical_declaration),
-        seq(field('initializer', $._expressions), ';'),
-        field('initializer', $.empty_statement),
-      ),
-      field('condition', choice(
-        seq($._expressions, ';'),
-        $.empty_statement,
-      )),
-      field('increment', optional($._expressions)),
-      ')',
+      forHeader($),
       field('body', $.statement),
     ),
 
     for_alt_statement: $ => seq(
-      'for',
-      '(',
-      choice(
-        field('initializer', $.lexical_declaration),
-        seq(field('initializer', $._expressions), ';'),
-        field('initializer', $.empty_statement),
-      ),
-      field('condition', choice(
-        seq($._expressions, ';'),
-        $.empty_statement,
-      )),
-      field('increment', optional($._expressions)),
-      ')',
+      forHeader($),
       ':',
       field('body', repeat($.statement)),
       'endfor',
@@ -491,7 +457,6 @@ module.exports = grammar({
       $.binary_expression,
       $.ternary_expression,
       $.update_expression,
-      $.import_expression,
     ),
 
     primary_expression: $ => choice(
@@ -515,14 +480,6 @@ module.exports = grammar({
       $.call_expression,
     ),
 
-    // Dynamic import expression: `let m = import("./mod.uc")`
-    import_expression: $ => prec('call', seq(
-      $.import,
-      '(',
-      field('source', $.expression),
-      ')',
-    )),
-
     object: $ => prec('object', seq(
       '{',
       commaSep(optional(choice(
@@ -680,7 +637,7 @@ module.exports = grammar({
       field('body', $.statement_block),
     )),
 
-    // Named function declaration with brace body
+    // Function declaration — brace body or alternative colon/endfunction syntax
     function_declaration: $ => prec.right('declaration', seq(
       'function',
       field('name', $.identifier),
@@ -692,13 +649,6 @@ module.exports = grammar({
       optional($._automatic_semicolon),
     )),
 
-    // Forward declaration: `function name;`
-    function_forward_declaration: $ => seq(
-      'function',
-      field('name', $.identifier),
-      ';',
-    ),
-
     arrow_function: $ => seq(
       choice(
         field('parameter', choice(
@@ -765,7 +715,7 @@ module.exports = grammar({
         /x[0-9a-fA-F]{2}/,
         /u[0-9a-fA-F]{4}/,
         /u\{[0-9a-fA-F]+\}/,
-        /[\r?][\n\u2028\u2029]/,
+        /\r[\n\u2028\u2029]/,
       ),
     )),
 
@@ -887,13 +837,30 @@ module.exports = grammar({
     _reserved_identifier: _ => choice(
       'get',
       'set',
-      'let',
     ),
 
     _semicolon: $ => choice($._automatic_semicolon, ';'),
   },
 });
 
+function forHeader($) {
+  return seq(
+    'for',
+    '(',
+    choice(
+      field('initializer', $.lexical_declaration),
+      seq(field('initializer', $._expressions), ';'),
+      field('initializer', $.empty_statement),
+    ),
+    field('condition', choice(
+      seq($._expressions, ';'),
+      $.empty_statement,
+    )),
+    field('increment', optional($._expressions)),
+    ')',
+  );
+}
+
 function commaSep1(rule) {
   return seq(rule, repeat(seq(',', rule)));
 }

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "tree-sitter-ucode",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Ucode grammar for tree-sitter",
-  "repository": "https://github.com/m00qek/tree-sitter-ucode",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/m00qek/tree-sitter-ucode.git"
+  },
   "license": "MIT",
   "main": "bindings/node",
   "types": "bindings/node",

package/queries/highlights.scm

@@ -53,9 +53,6 @@
 (function_declaration
   name: (identifier) @function)
 
-(function_forward_declaration
-  name: (identifier) @function)
-
 (function_expression
   name: (identifier) @function)
 
@@ -121,8 +118,6 @@
 
 ["import" "export"] @keyword.import
 ["as" "from"] @keyword.import
-; Dynamic import() uses a named node, not an anonymous string
-(import_expression (import) @keyword.import)
 
 ; -------------------------------------------------------------------------
 ; Keywords — storage / operators

package/queries/locals.scm

@@ -6,7 +6,6 @@
 ; -------------------------------------------------------------------------
 
 (function_declaration) @local.scope
-; function_forward_declaration has no body — it is a definition, not a scope
 (function_expression) @local.scope
 (arrow_function) @local.scope
 ; statement_block provides block scoping for let/const
@@ -23,16 +22,12 @@
 ; Definitions — functions
 ; -------------------------------------------------------------------------
 
-; Declaration and forward-declaration names belong to the *enclosing* scope
-; so that callers outside the function body can resolve them.
+; Function declaration names belong to the enclosing scope so that
+; callers outside the function body can resolve them.
 (function_declaration
   name: (identifier) @local.definition.function
   (#set! definition.function.scope parent))
 
-(function_forward_declaration
-  name: (identifier) @local.definition.function
-  (#set! definition.function.scope parent))
-
 ; Named function expressions (let f = function foo() {}) keep their name
 ; *inside* the expression scope — foo is only visible for self-recursion,
 ; not to the surrounding block.  No (#set! parent) here.

package/queries/tags.scm

@@ -14,19 +14,6 @@
   (#select-adjacent! @doc @definition.function)
 )
 
-; -------------------------------------------------------------------------
-; Function definitions — forward declarations: `function name;`
-; -------------------------------------------------------------------------
-
-(
-  (comment)* @doc
-  .
-  (function_forward_declaration
-    name: (identifier) @name) @definition.function
-  (#strip! @doc "^[\\s\\*/]+|^[\\s\\*/]$")
-  (#select-adjacent! @doc @definition.function)
-)
-
 ; -------------------------------------------------------------------------
 ; Function definitions — named function expressions
 ; -------------------------------------------------------------------------