feat: fix Grammar2 interpreter to correctly parse extern calls and impl blocks

Key fixes for Grammar2 runtime parsing:

- Add strip_name_bindings() to generator.rs to remove `name:rule` binding
  syntax from patterns when generating pest grammar (pest doesn't support
  named bindings)

- Fix prepend_list() helper in interpreter.rs to handle missing bindings
  when repetitions (*) match zero times, treating them as empty lists

- Update build_action_block() in ast.rs to extract return types from
  type_path nodes instead of expecting direct rust_type children

- Add regex dependency to zyn_peg for pattern processing

Grammar2 now correctly parses the full ZynML stdlib including:
- TypeAlias declarations
- All impl blocks (Display, Clone, Drop, Add, Sub, Mul, Div, Neg)
- extern calls as proper Call expressions
- Methods with associated types

All 133 ZynML tests pass.

Author: darmie

crates/typed_ast/src/lib.rs

@@ -148,7 +148,7 @@ pub use typed_ast::{
     TypedExtern, TypedExternClass, TypedExternStruct, TypedExternEnum,
     TypedExternEnumVariant, TypedExternTypeDef, TypedExternMethod, TypedExternProperty,
     // Trait implementation types
-    TypedTraitImpl, TypedImplAssociatedType,
+    TypedTraitImpl, TypedImplAssociatedType, TypedInterface,
 };
 
 pub use type_inference::{

crates/zyn_peg/Cargo.toml

@@ -26,6 +26,9 @@ log = "0.4"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 
+# Regex for pattern processing
+regex = "1.10"
+
 # Interned strings (shared with typed_ast)
 internment = "0.8"
 

crates/zyn_peg/generated/ast_builder.rs

@@ -3,23 +3,24 @@
 program = { SOI ~ declarations ~ EOI  }
 declarations = { declaration*  }
 declaration = { struct_decl | enum_decl | extern_fn_decl | fn_decl | const_decl | var_decl  }
-struct_decl = { "const" ~ identifier ~ "=" ~ "struct" ~ "{" ~ struct_fields? ~ "}" ~ ";"  }
-struct_fields = { struct_field ~ ("," ~ struct_field)* ~ ","?  }
-struct_field = { identifier ~ ":" ~ type_expr  }
-enum_decl = { "const" ~ identifier ~ "=" ~ "enum" ~ "{" ~ enum_variants? ~ "}" ~ ";"  }
-enum_variants = { enum_variant ~ ("," ~ enum_variant)* ~ ","?  }
-enum_variant = { identifier  }
+struct_decl = { "const" ~ identifier ~ "=" ~ "struct" ~ "{" ~ struct_field_list? ~ "}" ~ ";"  }
+struct_field_list = { struct_field*  }
+struct_field = { identifier ~ ":" ~ type_expr ~ ","?  }
+enum_decl = { "const" ~ identifier ~ "=" ~ "enum" ~ "{" ~ enum_variant_list? ~ "}" ~ ";"  }
+enum_variant_list = { enum_variant*  }
+enum_variant = { identifier ~ ","?  }
 extern_fn_decl = { extern_fn_decl_with_params | extern_fn_decl_no_params  }
-extern_fn_decl_with_params = { "extern" ~ "fn" ~ identifier ~ "(" ~ fn_params ~ ")" ~ type_expr ~ ";"  }
+extern_fn_decl_with_params = { "extern" ~ "fn" ~ identifier ~ "(" ~ fn_param_list ~ ")" ~ type_expr ~ ";"  }
 extern_fn_decl_no_params = { "extern" ~ "fn" ~ identifier ~ "(" ~ ")" ~ type_expr ~ ";"  }
 fn_decl = { async_fn_decl | sync_fn_decl  }
 sync_fn_decl = { fn_decl_with_params | fn_decl_no_params  }
 async_fn_decl = { async_fn_decl_with_params | async_fn_decl_no_params  }
-async_fn_decl_with_params = { "async" ~ "fn" ~ identifier ~ "(" ~ fn_params ~ ")" ~ type_expr ~ block  }
+async_fn_decl_with_params = { "async" ~ "fn" ~ identifier ~ "(" ~ fn_param_list ~ ")" ~ type_expr ~ block  }
 async_fn_decl_no_params = { "async" ~ "fn" ~ identifier ~ "(" ~ ")" ~ type_expr ~ block  }
-fn_decl_with_params = { "fn" ~ identifier ~ "(" ~ fn_params ~ ")" ~ type_expr ~ block  }
+fn_decl_with_params = { "fn" ~ identifier ~ "(" ~ fn_param_list ~ ")" ~ type_expr ~ block  }
 fn_decl_no_params = { "fn" ~ identifier ~ "(" ~ ")" ~ type_expr ~ block  }
-fn_params = { fn_param_any ~ ("," ~ fn_param_any)*  }
+fn_param_list = { fn_param_item*  }
+fn_param_item = { fn_param_any ~ ","?  }
 fn_param_any = { comptime_param | fn_param  }
 comptime_param = { "comptime" ~ identifier ~ ":" ~ type_expr  }
 fn_param = { identifier ~ ":" ~ type_expr  }
@@ -29,12 +30,13 @@ const_decl_untyped = { "const" ~ identifier ~ "=" ~ expr ~ ";"  }
 var_decl = { var_decl_typed | var_decl_untyped  }
 var_decl_typed = { "var" ~ identifier ~ ":" ~ type_expr ~ "=" ~ expr ~ ";"  }
 var_decl_untyped = { "var" ~ identifier ~ "=" ~ expr ~ ";"  }
-type_expr = { pointer_type | optional_type | error_union_type | array_type | primitive_type | identifier  }
+type_expr = { pointer_type | optional_type | error_union_type | array_type | primitive_type | named_type  }
 pointer_type = { "*" ~ "const"? ~ type_expr  }
 optional_type = { "?" ~ type_expr  }
 error_union_type = { "!" ~ type_expr  }
 array_type = { "[" ~ integer_literal? ~ "]" ~ type_expr  }
-primitive_type = { "i8" | "i16" | "i32" | "i64" | "u8" | "u16" | "u32" | "u64" | "f32" | "f64" | "bool" | "void" | "type"  }
+primitive_type = @{ "i8" | "i16" | "i32" | "i64" | "u8" | "u16" | "u32" | "u64" | "f32" | "f64" | "bool" | "void" | "type"  }
+named_type = { identifier  }
 statement = { if_stmt | while_stmt | for_stmt | return_stmt | break_stmt | continue_stmt | local_const | local_var | assign_stmt | expr_stmt  }
 break_stmt = { "break" ~ ";"  }
 continue_stmt = { "continue" ~ ";"  }
@@ -53,52 +55,33 @@ local_var_typed = { "var" ~ identifier ~ ":" ~ type_expr ~ "=" ~ expr ~ ";"  }
 local_var_untyped = { "var" ~ identifier ~ "=" ~ expr ~ ";"  }
 expr_stmt = { expr ~ ";"  }
 block = { "{" ~ statement* ~ "}"  }
-expr = { logical_or  }
-logical_or = { logical_and ~ (or_op ~ logical_and)*  }
-logical_and = { comparison ~ (and_op ~ comparison)*  }
-comparison = { addition ~ ((eq_op | neq_op | lte_op | gte_op | lt_op | gt_op) ~ addition)*  }
-addition = { multiplication ~ ((add_op | sub_op) ~ multiplication)*  }
-multiplication = { unary ~ ((mul_op | div_op) ~ unary)*  }
-unary = { unary_with_op | primary  }
+expr = { comparison_expr  }
+comparison_expr = { add_expr ~ (comparison_op ~ add_expr)?  }
+comparison_op = @{ "==" | "!=" | "<=" | ">=" | "<" | ">"  }
+add_expr = { mul_expr ~ (add_op ~ mul_expr)?  }
+add_op = @{ "+" | "-"  }
+mul_expr = { unary_expr ~ (mul_op ~ unary_expr)?  }
+mul_op = @{ "*" | "/"  }
+unary_expr = { unary_with_op | primary  }
 unary_with_op = { unary_op ~ primary  }
+unary_op = { "-" | "!"  }
 primary = { postfix_expr  }
 postfix_expr = { call_expr | field_expr | index_expr | atom  }
-call_expr = { atom ~ "(" ~ call_args? ~ ")"  }
+call_expr = { atom ~ "(" ~ call_arg_list? ~ ")"  }
+call_arg_list = { call_arg*  }
+call_arg = { expr ~ ","?  }
 field_expr = { atom ~ "." ~ identifier  }
 index_expr = { atom ~ "[" ~ expr ~ "]"  }
-call_args = { expr ~ ("," ~ expr)*  }
-atom = { switch_expr | try_expr | await_expr | struct_init | array_literal | bool_literal | string_literal | integer_literal | type_value | identifier_expr | paren_expr  }
-switch_expr = { "switch" ~ "(" ~ expr ~ ")" ~ "{" ~ switch_cases? ~ "}"  }
-switch_cases = { switch_case ~ ("," ~ switch_case)* ~ ","?  }
-switch_case = { switch_case_value | switch_case_else  }
-switch_case_value = { switch_pattern ~ "=>" ~ expr  }
-switch_case_else = { "else" ~ "=>" ~ expr  }
-switch_pattern = { switch_or_pattern  }
-switch_or_pattern = { switch_primary_pattern ~ ("|" ~ switch_primary_pattern)*  }
-switch_primary_pattern = { switch_struct_pattern | switch_tagged_union_pattern | switch_error_pattern | switch_pointer_pattern | switch_range_pattern | switch_array_pattern | switch_literal_pattern | switch_wildcard_pattern | switch_identifier_pattern  }
-switch_range_pattern = { switch_simple_literal ~ ".." ~ switch_simple_literal  }
-switch_array_pattern = { ".{" ~ switch_array_elements? ~ "}"  }
-switch_array_elements = { switch_pattern ~ ("," ~ switch_pattern)* ~ ","?  }
-switch_literal_pattern = { switch_simple_literal  }
-switch_simple_literal = { integer_literal | string_literal  }
-switch_wildcard_pattern = { "_"  }
-switch_identifier_pattern = { identifier  }
-switch_struct_pattern = { identifier ~ "{" ~ switch_struct_field_patterns? ~ "}"  }
-switch_struct_field_patterns = { switch_struct_field_pattern ~ ("," ~ switch_struct_field_pattern)* ~ ","?  }
-switch_struct_field_pattern = { "." ~ identifier ~ ("=" ~ switch_pattern)?  }
-switch_tagged_union_pattern = { "." ~ identifier  }
-switch_error_pattern = { "error" ~ "." ~ identifier  }
-switch_pointer_pattern = { "*" ~ switch_primary_pattern  }
-type_value = { type_expr_as_value  }
-type_expr_as_value = { primitive_type  }
-struct_init = { identifier ~ "{" ~ struct_init_fields? ~ "}"  }
-struct_init_fields = { struct_init_field ~ ("," ~ struct_init_field)* ~ ","?  }
-struct_init_field = { "." ~ identifier ~ "=" ~ expr  }
+atom = { try_expr | await_expr | struct_init | array_literal | bool_literal | string_literal | integer_literal | identifier_expr | paren_expr  }
 try_expr = { "try" ~ primary  }
 await_expr = { "await" ~ primary  }
+struct_init = { identifier ~ "{" ~ struct_init_field_list? ~ "}"  }
+struct_init_field_list = { struct_init_field*  }
+struct_init_field = { "." ~ identifier ~ "=" ~ expr ~ ","?  }
+array_literal = { "[" ~ array_element_list? ~ "]"  }
+array_element_list = { array_element*  }
+array_element = { expr ~ ","?  }
 paren_expr = _{ "(" ~ expr ~ ")"  }
-array_literal = { "[" ~ array_elements? ~ "]"  }
-array_elements = { expr ~ ("," ~ expr)*  }
 identifier_expr = { identifier  }
 bool_literal = { "true" | "false"  }
 integer_literal = @{ "-"? ~ ASCII_DIGIT+  }
@@ -107,23 +90,10 @@ string_inner = { (!("\"" | "\\") ~ ANY) | escape_seq  }
 escape_seq = { "\\" ~ ("n" | "r" | "t" | "\\" | "\"" | "0")  }
 keyword = @{ ("struct" | "enum" | "fn" | "const" | "var" | "if" | "else" | "while" | "for" |
      "return" | "break" | "continue" | "try" | "await" | "async" | "and" | "or" | "true" | "false" |
-     "comptime" | "type" | "switch" |
+     "comptime" | "type" | "switch" | "extern" | "error" |
      "i8" | "i16" | "i32" | "i64" | "u8" | "u16" | "u32" | "u64" | "f32" | "f64" | "bool" | "void")
     ~ !(ASCII_ALPHANUMERIC | "_")
  }
 identifier = @{ !keyword ~ (ASCII_ALPHA | "_") ~ (ASCII_ALPHANUMERIC | "_")*  }
-and_op = { "and"  }
-or_op = { "or"  }
-eq_op = { "=="  }
-neq_op = { "!="  }
-lte_op = { "<="  }
-gte_op = { ">="  }
-lt_op = { "<"  }
-gt_op = { ">"  }
-add_op = { "+"  }
-sub_op = { "-"  }
-mul_op = { "*"  }
-div_op = { "/"  }
-unary_op = { "-" | "!"  }
 WHITESPACE = _{ " " | "\t" | "\n" | "\r"  }
 COMMENT = _{ "//" ~ (!"\n" ~ ANY)* ~ "\n"?  }

crates/zyn_peg/generated/zig.pest

@@ -294,9 +294,21 @@ fn build_action_block(pair: Pair<Rule>) -> Result<ActionBlock, String> {
 
     for inner in pair.into_inner() {
         match inner.as_rule() {
+            Rule::type_path => {
+                // type_path = { rust_type ~ ("::" ~ identifier)? }
+                // Extract the full type path including variant
+                return_type = inner.as_str().trim().to_string();
+            }
             Rule::rust_type => {
+                // Legacy support: direct rust_type
                 return_type = inner.as_str().trim().to_string();
             }
+            Rule::identifier => {
+                // Helper function call or passthrough: -> intern(binding) or -> binding
+                if return_type.is_empty() {
+                    return_type = inner.as_str().trim().to_string();
+                }
+            }
             Rule::action_body => {
                 for field_pair in inner.into_inner() {
                     match field_pair.as_rule() {

crates/zyn_peg/src/ast.rs

@@ -1038,6 +1038,20 @@ pub fn generate_pest_grammar_string(grammar: &ZynGrammar) -> Result<String> {
     generate_pest_grammar(grammar)
 }
 
+/// Strip name bindings from a pattern for pest compatibility.
+/// Converts `name:rule` to just `rule` since pest doesn't support named bindings.
+///
+/// Examples:
+/// - `items:top_level_items` -> `top_level_items`
+/// - `name:identifier ~ ":" ~ value:expr` -> `identifier ~ ":" ~ expr`
+fn strip_name_bindings(pattern: &str) -> String {
+    use regex::Regex;
+    // Match identifier followed by colon followed by identifier (the binding syntax)
+    // We need to handle cases like `name:identifier` but not break strings like `":"`
+    let re = Regex::new(r"\b([a-zA-Z_][a-zA-Z0-9_]*):([a-zA-Z_][a-zA-Z0-9_]*)").unwrap();
+    re.replace_all(pattern, "$2").to_string()
+}
+
 /// Generate a pest-compatible grammar from ZynGrammar rules
 fn generate_pest_grammar(grammar: &ZynGrammar) -> Result<String> {
     let mut lines = Vec::new();
@@ -1059,9 +1073,12 @@ fn generate_pest_grammar(grammar: &ZynGrammar) -> Result<String> {
             None => "",
         };
 
+        // Strip name bindings from the pattern for pest compatibility
+        let pest_pattern = strip_name_bindings(&rule.pattern);
+
         lines.push(format!(
             "{} = {}{{ {} }}",
-            rule.name, modifier, rule.pattern
+            rule.name, modifier, pest_pattern
         ));
     }
 

crates/zyn_peg/src/generator.rs

@@ -524,6 +524,28 @@ impl<'a> GrammarParser<'a> {
         let first_path = self.parse_type_path()?;
         self.skip_ws();
 
+        // Check for function call: -> intern(name)
+        if self.peek_char() == Some('(') {
+            self.advance(); // consume '('
+            self.skip_ws();
+
+            // Parse arguments
+            let mut args = Vec::new();
+            while self.peek_char() != Some(')') {
+                let arg = self.parse_expr()?;
+                args.push(arg);
+                self.skip_ws();
+                if self.peek_char() == Some(',') {
+                    self.advance();
+                    self.skip_ws();
+                }
+            }
+            self.expect_char(')')?;
+
+            // Function call action
+            return Ok((ActionIR::HelperCall { function: first_path.clone(), args }, "Any".to_string()));
+        }
+
         // Check for simple pass-through: -> binding (no '{' follows)
         // If the first_path is a simple identifier (no ::) and no '{' follows,
         // it's a pass-through action