parser-lr 0.7.0 → 0.8.0

package/docs/grammar.md

@@ -116,6 +116,19 @@ ast
         #binary [left]:expr [operator]:operator [right]:expr
       | #literal number
       ;
+
+    list =
+        #list { item }
+      ;
+```
+
+Every `type.#variant` referenced from `transform` must appear as a `#variant` label on that AST type, including types with only one alternative:
+
+```ebnf
+ast
+    program =
+        #program { form }
+      ;
 ```
 
 When present, transform rules map parse trees to these types.
@@ -161,9 +174,48 @@ transform
 |-----------|----------|
 | `pass(slot)` | Lift one bound child unchanged. `pass(boundSlot)` preserves the bound production symbol and its `#` variant. `pass(terminalName)` at the same rule may collapse to that terminal. |
 | `build(type.#variant, …)` | Construct an AST node with a fixed shape. Omit absent optional bindings from the argument list. |
-| `flatten(type.#variant, head, tail)` | Turn a `{ repeat }` list into one AST node with ordered children. Use the repeat non-terminal (for example `list$repeat_0`) as `tail` on the head production. |
+| `flatten(type.#variant, head, tail)` | Turn a `head { … }` list into one AST node with ordered children. Prefer putting `flatten` on the **parent** production that owns the required head and the synthetic repeat tail. |
+
+Preferred parent-flatten pattern for a required head plus optional rest:
+
+```ebnf
+grammar
+    list =
+        #list [first]:item { comma [rest]:item }
+      ;
+
+ast
+    list =
+        #list { item }
+      ;
+
+transform
+    list ->
+        #list flatten(list.#list, first, list$repeat_0) ;
+```
+
+Use a `$repeat_*` helper transform when the list is zero-or-more and nested among other fields, or when the parent must `build(...)` a wrapper around the flattened list. The transform language cannot nest `flatten(...)` inside `type.#variant(...)` arguments:
+
+```ebnf
+transform
+    program ->
+        #main pass(program$repeat_0)
+      ;
+
+    program$repeat_0 ->
+        #main flatten(program.#program, item, program$repeat_0)
+      ;
+
+    wrapped_list ->
+        #main wrapped_list.#wrapped(open, wrapped_list$repeat_0, close)
+      ;
+
+    wrapped_list$repeat_0 ->
+        #main flatten(wrapped_list.#items, member, wrapped_list$repeat_0)
+      ;
+```
 
-**Production symbols are preserved.** When a CST node has parse-table metadata, transforms keep its production name even if it has only one terminal child. Bare `CLS` through `pass(stmt)` where `[stmt]:cls_stmt` yields an `cls_stmt` node, not `kw_cls`.
+**Production symbols are preserved.** When a CST node has parse-table metadata, transforms keep its production name even if it has only one terminal child. Bare `CLS` through `pass(stmt)` where `[stmt]:cls_stmt` yields a `cls_stmt` node, not `kw_cls`.
 
 ### Transform contract
 
@@ -195,7 +247,7 @@ Before / after for `CASE IS < 0` with `case_selector = #relational kw_is compari
 Run `parser-lr table validate -g mylang.grammar` to check `ast` / `transform` consistency. The validator:
 
 - warns when `pass(boundSlot)` targets a production that can match a single terminal and has no transform rule;
-- errors when a `build` / `fold` / `flatten` references a `type.#variant` not declared in `ast`;
+- errors when a `build` / `fold` / `flatten` references a `type.#variant` not declared in `ast`, including single-alternative labeled types;
 - warns when a production, `ast` type, or `transform` rule is declared more than once (the later definition silently overrides the earlier one).
 
 Add `--strict` to fail on warnings in CI.

package/grammars/6502.grammar

@@ -112,7 +112,7 @@ grammar
 
 ast
     program =
-        { line }
+        #program { line }
     ;
 
     line =
@@ -122,7 +122,7 @@ ast
     ;
 
     directive =
-        [dotTok]:dot
+        #directive [dotTok]:dot
         [sym]:identifier
         [value]:hex_number
     ;

package/grammars/ferrite.grammar

@@ -1,24 +1,28 @@
-// Ferrite — a C-like language with C#-style structs, namespaces, and pointer semantics.
-// No preprocessor; sources compile as single units (namespaces + using, like C# assemblies).
+// Ferrite — a C-like language with C#-style structs, file-scoped namespaces, and pointer semantics.
+// No preprocessor; sources compile as single units (namespaces + using).
+// Naming convention (not enforced by the grammar): PascalCase types, camelCase functions and variables.
 //
 // Example:
 //
-//   namespace Ferrite.Math {
-//       struct Vec2 {
-//           float32 x;
-//           float32 y;
-//           float32 dot(Vec2* other) {
-//               return x * other->x + y * other->y;
-//           }
-//       }
-//   }
+//   namespace Ferrite.Math;
 //
-//   using Ferrite.Math;
+//   using Ferrite.Core;
 //
-//   int32 main() {
+//   public struct Vec2
+//   {
+//       Float32 x;
+//       Float32 y;
+//       Float32 dot(Vec2* other)
+//       {
+//           return x * other->x + y * other->y;
+//       }
+//   };
+//
+//   public Int32 main()
+//   {
 //       Vec2 a = { 1.0, 2.0 };
 //       Vec2* p = &a;
-//       return (int32)p->dot(&a);
+//       return (Int32)p->dot(&a);
 //   }
 
 name "ferrite" ;
@@ -27,6 +31,8 @@ tokens
     kw_struct = /struct/ ;
     kw_namespace = /namespace/ ;
     kw_using = /using/ ;
+    kw_public = /public/ ;
+    kw_private = /private/ ;
     kw_if = /if/ ;
     kw_else = /else/ ;
     kw_while = /while/ ;
@@ -38,19 +44,19 @@ tokens
     kw_null = /null/ ;
     kw_true = /true/ ;
     kw_false = /false/ ;
-    kw_void = /void/ ;
-    kw_bool = /bool/ ;
-    kw_int8 = /int8/ ;
-    kw_int16 = /int16/ ;
-    kw_int32 = /int32/ ;
-    kw_int64 = /int64/ ;
-    kw_uint8 = /uint8/ ;
-    kw_uint16 = /uint16/ ;
-    kw_uint32 = /uint32/ ;
-    kw_uint64 = /uint64/ ;
-    kw_float32 = /float32/ ;
-    kw_float64 = /float64/ ;
-    kw_char = /char/ ;
+    kw_void = /Void/ ;
+    kw_bool = /Bool/ ;
+    kw_int8 = /Int8/ ;
+    kw_int16 = /Int16/ ;
+    kw_int32 = /Int32/ ;
+    kw_int64 = /Int64/ ;
+    kw_uint8 = /UInt8/ ;
+    kw_uint16 = /UInt16/ ;
+    kw_uint32 = /UInt32/ ;
+    kw_uint64 = /UInt64/ ;
+    kw_float32 = /Float32/ ;
+    kw_float64 = /Float64/ ;
+    kw_char = /Char/ ;
 
     identifier = /[A-Za-z_][A-Za-z0-9_]*/ ;
     int_literal = /0x[0-9A-F]+|0b[01]+|[0-9]+/i ;
@@ -112,28 +118,27 @@ start program ;
 
 grammar
     program =
+        [ [ns]:file_namespace ]
+        { [use]:using_directive }
         { [decl]:top_decl }
     ;
 
-    top_decl =
-        #namespace [nsKw]:kw_namespace [qname]:qualified_name [body]:namespace_body
-      | #using [useKw]:kw_using [qname]:qualified_name [semi]:semicolon
-      | #struct struct_decl
-      | #function function_decl
+    file_namespace =
+        [nsKw]:kw_namespace [qname]:qualified_name [semi]:semicolon
     ;
 
-    namespace_body =
-        [open]:lbrace
-        { [member]:namespace_member }
-        [close]:rbrace
+    using_directive =
+        [useKw]:kw_using [qname]:qualified_name [semi]:semicolon
     ;
 
-    namespace_member =
+    top_decl =
         #struct struct_decl
       | #function function_decl
-      | #namespace [nsKw]:kw_namespace [qname]:qualified_name [body]:namespace_body
-      | #using [useKw]:kw_using [qname]:qualified_name [semi]:semicolon
-      | #statement [stmt]:statement
+    ;
+
+    access_modifier =
+        #public [keyword]:kw_public
+      | #private [keyword]:kw_private
     ;
 
     qualified_name =
@@ -145,6 +150,7 @@ grammar
     ;
 
     struct_decl =
+        [access]:access_modifier
         [structKw]:kw_struct
         [sym]:identifier
         [body]:struct_body
@@ -186,12 +192,14 @@ grammar
 
     function_decl =
         #defined
+        [access]:access_modifier
         [type]:type_spec
         [sym]:identifier
         [open]:lpar
         [close]:rpar
         [body]:block
       | #definedParams
+        [access]:access_modifier
         [type]:type_spec
         [sym]:identifier
         [open]:lpar
@@ -199,12 +207,14 @@ grammar
         [close]:rpar
         [body]:block
       | #prototype
+        [access]:access_modifier
         [type]:type_spec
         [sym]:identifier
         [open]:lpar
         [close]:rpar
         [semi]:semicolon
       | #prototypeParams
+        [access]:access_modifier
         [type]:type_spec
         [sym]:identifier
         [open]:lpar
@@ -273,7 +283,7 @@ grammar
     ;
 
     expr_sep =
-        [commaTok]:comma [rest]:expression
+        #sep [commaTok]:comma [rest]:expression
     ;
 
     for_init =
@@ -425,39 +435,45 @@ grammar
 
 ast
     program =
-        { top_decl }
+        #program [ [ns]:file_namespace ] [usings]:using_list [decls]:decl_list
     ;
 
-    top_decl =
-        #namespace [nsKw]:kw_namespace [qname]:qualified_name [body]:namespace_body
-      | #using [useKw]:kw_using [qname]:qualified_name [semi]:semicolon
-      | #struct struct_decl
-      | #function function_decl
+    using_list =
+        #list { using_directive }
     ;
 
-    namespace_body =
-        [open]:lbrace
-        { [member]:namespace_member }
-        [close]:rbrace
+    decl_list =
+        #list { top_decl }
+    ;
+
+    file_namespace =
+        #file_namespace [nsKw]:kw_namespace [qname]:qualified_name [semi]:semicolon
+    ;
+
+    using_directive =
+        #using_directive [useKw]:kw_using [qname]:qualified_name [semi]:semicolon
     ;
 
-    namespace_member =
+    top_decl =
         #struct struct_decl
       | #function function_decl
-      | #namespace [nsKw]:kw_namespace [qname]:qualified_name [body]:namespace_body
-      | #using [useKw]:kw_using [qname]:qualified_name [semi]:semicolon
-      | #statement [stmt]:statement
+    ;
+
+    access_modifier =
+        #public [keyword]:kw_public
+      | #private [keyword]:kw_private
     ;
 
     qualified_name =
-        [head]:identifier { name_part }
+        #qualified_name [head]:identifier { name_part }
     ;
 
     name_part =
-        [dotTok]:dot [part]:identifier
+        #part [dotTok]:dot [part]:identifier
     ;
 
     struct_decl =
+        #struct_decl [access]:access_modifier
         [structKw]:kw_struct
         [sym]:identifier
         [body]:struct_body
@@ -465,7 +481,7 @@ ast
     ;
 
     struct_body =
-        [open]:lbrace
+        #struct_body [open]:lbrace
         { [member]:struct_member }
         [close]:rbrace
     ;
@@ -476,7 +492,7 @@ ast
     ;
 
     field_decl =
-        [type]:type_spec
+        #field_decl [type]:type_spec
         [sym]:identifier
         [semi]:semicolon
     ;
@@ -499,12 +515,14 @@ ast
 
     function_decl =
         #defined
+        [access]:access_modifier
         [type]:type_spec
         [sym]:identifier
         [open]:lpar
         [close]:rpar
         [body]:block
       | #definedParams
+        [access]:access_modifier
         [type]:type_spec
         [sym]:identifier
         [open]:lpar
@@ -512,12 +530,14 @@ ast
         [close]:rpar
         [body]:block
       | #prototype
+        [access]:access_modifier
         [type]:type_spec
         [sym]:identifier
         [open]:lpar
         [close]:rpar
         [semi]:semicolon
       | #prototypeParams
+        [access]:access_modifier
         [type]:type_spec
         [sym]:identifier
         [open]:lpar
@@ -531,16 +551,17 @@ ast
     ;
 
     param_sep =
-        [commaTok]:comma [rest]:param
+        #sep [commaTok]:comma [rest]:param
     ;
 
     param =
-        [type]:type_spec
+        #param [type]:type_spec
         [sym]:identifier
     ;
 
     type_spec =
-        #voidType [voidKw]:kw_void { [ptr]:star }
+        #pointers { [ptr]:star }
+      | #voidType [voidKw]:kw_void { [ptr]:star }
       | #bool [boolKw]:kw_bool { [ptr]:star }
       | #int8 [int8Kw]:kw_int8 { [ptr]:star }
       | #int16 [int16Kw]:kw_int16 { [ptr]:star }
@@ -559,7 +580,7 @@ ast
     ;
 
     block =
-        [open]:lbrace
+        #block [open]:lbrace
         { statement }
         [close]:rbrace
     ;
@@ -586,7 +607,7 @@ ast
     ;
 
     expr_sep =
-        [commaTok]:comma [rest]:expression
+        #sep [commaTok]:comma [rest]:expression
     ;
 
     for_init =
@@ -738,41 +759,39 @@ ast
 
 transform
     program ->
-        #main pass(program$repeat_0) ;
+        #main program.#program(ns, program$repeat_0, program$repeat_1) ;
 
     program$repeat_0 ->
-        #main flatten(program.#program, decl, program$repeat_0) ;
+        #main flatten(using_list.#list, use, program$repeat_0) ;
 
-    top_decl ->
-        #namespace top_decl.#namespace(nsKw, qname, body)
-      | #using top_decl.#using(useKw, qname, semi)
-      | #struct pass(struct_decl)
-      | #function pass(function_decl) ;
+    program$repeat_1 ->
+        #main flatten(decl_list.#list, decl, program$repeat_1) ;
 
-    namespace_body ->
-        #main namespace_body.#namespace_body(open, namespace_body$repeat_0, close) ;
+    file_namespace ->
+        #main file_namespace.#file_namespace(nsKw, qname, semi) ;
 
-    namespace_body$repeat_0 ->
-        #main flatten(namespace_body.#namespace_body, member, namespace_body$repeat_0) ;
+    using_directive ->
+        #main using_directive.#using_directive(useKw, qname, semi) ;
 
-    namespace_member ->
+    top_decl ->
         #struct pass(struct_decl)
-      | #function pass(function_decl)
-      | #namespace namespace_member.#namespace(nsKw, qname, body)
-      | #using namespace_member.#using(useKw, qname, semi)
-      | #statement pass(stmt) ;
+      | #function pass(function_decl) ;
+
+    access_modifier ->
+        #public access_modifier.#public(keyword)
+      | #private access_modifier.#private(keyword) ;
 
     qualified_name ->
-        #main qualified_name.#qualified_name(head, qualified_name$repeat_1) ;
+        #main qualified_name.#qualified_name(head, qualified_name$repeat_0) ;
 
-    qualified_name$repeat_1 ->
-        #main flatten(qualified_name.#qualified_name, name_part, qualified_name$repeat_1) ;
+    qualified_name$repeat_0 ->
+        #main flatten(qualified_name.#qualified_name, name_part, qualified_name$repeat_0) ;
 
     name_part ->
         #main name_part.#part(dotTok, part) ;
 
     struct_decl ->
-        #main struct_decl.#struct_decl(structKw, sym, body, semi) ;
+        #main struct_decl.#struct_decl(access, structKw, sym, body, semi) ;
 
     struct_body ->
         #main struct_body.#struct_body(open, struct_body$repeat_0, close) ;
@@ -792,17 +811,14 @@ transform
       | #methodParams method_decl.#method(type, sym, open, params, close, body) ;
 
     function_decl ->
-        #defined function_decl.#defined(type, sym, open, close, body)
-      | #definedParams function_decl.#defined(type, sym, open, params, close, body)
-      | #prototype function_decl.#prototype(type, sym, open, close, semi)
-      | #prototypeParams function_decl.#prototype(type, sym, open, params, close, semi) ;
+        #defined function_decl.#defined(access, type, sym, open, close, body)
+      | #definedParams function_decl.#defined(access, type, sym, open, params, close, body)
+      | #prototype function_decl.#prototype(access, type, sym, open, close, semi)
+      | #prototypeParams function_decl.#prototype(access, type, sym, open, params, close, semi) ;
 
     param_list ->
         #main flatten(param_list.#list, first, param_list$repeat_0) ;
 
-    param_list$repeat_0 ->
-        #main flatten(param_list.#list, param_sep, param_list$repeat_0) ;
-
     param_sep ->
         #main param_sep.#sep(commaTok, rest) ;
 
@@ -854,9 +870,6 @@ transform
     init_list ->
         #main flatten(init_list.#list, first, init_list$repeat_0) ;
 
-    init_list$repeat_0 ->
-        #main flatten(init_list.#list, expr_sep, init_list$repeat_0) ;
-
     expr_sep ->
         #main expr_sep.#sep(commaTok, rest) ;
 
@@ -974,9 +987,6 @@ transform
     arg_list ->
         #main flatten(arg_list.#list, first, arg_list$repeat_0) ;
 
-    arg_list$repeat_0 ->
-        #main flatten(arg_list.#list, expr_sep, arg_list$repeat_0) ;
-
     primary_expr ->
         #ident pass(sym)
       | #int pass(value)