refactor: grammar of struct def and func decl

Author: Boreas618

docs/tealang.md

@@ -112,8 +112,13 @@ typed_array_decl  := identifier < : > < [ > typeSpec < ; > num < ] >       // ar
 varDecl := typed_array_decl
          | typed_scalar_decl
          | scalar_decl
+
+typedVarDecl := typed_array_decl
+              | typed_scalar_decl
 ```
 
+`varDecl` (with optional type) is used in `let` statements where type inference is allowed. `typedVarDecl` (type required) is used for struct fields and function parameters where types are mandatory.
+
 Since `typeSpec` includes reference types (`&[T]`), a `typed_scalar_decl` like `arr: &[i32]` declares a slice reference parameter. This form is only valid in function parameter lists — it cannot appear in `let` statements or struct fields. This constraint is enforced semantically, not syntactically.
 
 Examples:
@@ -155,11 +160,12 @@ let count = 0;                          // type inference scalar
 
 ## Structure Definitions
 
-Define custom types using the `struct` keyword with named fields. Struct fields use `varDecl` (scalars and arrays only; reference types are not permitted as struct fields).
+Define custom types using the `struct` keyword with named fields. Struct fields must have type annotations (reference types are not permitted as struct fields).
 
 ```
-structDef := < struct > identifier < { > varDeclList < } >
-varDeclList := varDecl (< , > varDecl)*
+structDef := < struct > identifier < { > typedVarDeclList < } >
+typedVarDeclList := typedVarDecl (< , > typedVarDecl)*
+typedVarDecl := typed_array_decl | typed_scalar_decl
 ```
 
 Example:
@@ -176,13 +182,13 @@ struct Node {
 
 ### Function Declarations
 
-Declare function signatures with optional return types. Function parameters use `varDecl`, which includes reference-typed parameters like `arr: &[i32]` via `typeSpec`.
+Declare function signatures with optional return types. Function parameters must have type annotations, including reference-typed parameters like `arr: &[i32]` via `typeSpec`.
 
 ```
 fnDeclStmt := fnDecl < ; >
 fnDecl := < fn > identifier < ( > paramDecl? < ) > < -> > typeSpec   // with return type
         | < fn > identifier < ( > paramDecl? < ) >                   // without return type
-paramDecl := varDeclList
+paramDecl := typedVarDeclList
 ```
 
 Examples:

src/parser/decl.rs

@@ -62,18 +62,18 @@ impl<'a> ParseContext<'a> {
         for inner in pair.into_inner() {
             match inner.as_rule() {
                 Rule::identifier => identifier = inner.as_str().to_string(),
-                Rule::var_decl_list => decls = self.parse_var_decl_list(inner)?,
+                Rule::typed_var_decl_list => decls = self.parse_typed_var_decl_list(inner)?,
                 _ => {}
             }
         }
 
         Ok(Box::new(ast::StructDef { identifier, decls }))
     }
 
-    pub(crate) fn parse_var_decl_list(&self, pair: Pair) -> ParseResult<Vec<ast::VarDecl>> {
+    pub(crate) fn parse_typed_var_decl_list(&self, pair: Pair) -> ParseResult<Vec<ast::VarDecl>> {
         let mut decls = Vec::new();
         for inner in pair.into_inner() {
-            if inner.as_rule() == Rule::var_decl {
+            if inner.as_rule() == Rule::typed_var_decl {
                 decls.push(*self.parse_var_decl(inner)?);
             }
         }
@@ -326,9 +326,9 @@ impl<'a> ParseContext<'a> {
     fn parse_param_decl(&self, pair: Pair) -> ParseResult<Box<ast::ParamDecl>> {
         let pair_for_error = pair.clone();
         for inner in pair.into_inner() {
-            if inner.as_rule() == Rule::var_decl_list {
+            if inner.as_rule() == Rule::typed_var_decl_list {
                 return Ok(Box::new(ast::ParamDecl {
-                    decls: self.parse_var_decl_list(inner)?,
+                    decls: self.parse_typed_var_decl_list(inner)?,
                 }));
             }
         }

src/tealang.pest

@@ -156,14 +156,21 @@ program_element = {
 // Define a structure with named fields
 // Example: "struct Node { value:i32, next:i32 }"
 struct_def = {
-    kw_struct ~ identifier ~ lbrace ~ var_decl_list ~ rbrace
+    kw_struct ~ identifier ~ lbrace ~ typed_var_decl_list ~ rbrace
 }
 
-// Variable declarations
-// List of variable declarations separated by commas
+// Typed variable declaration: must have a type annotation (no untyped scalars)
+// Used for struct fields and function parameters where types are mandatory
+// Examples: "n:i32", "arr: [i32; 100]", "input: &[i32]"
+typed_var_decl = {
+    identifier ~ colon ~ lbracket ~ type_spec ~ semicolon ~ num ~ rbracket  // array with type
+    | identifier ~ colon ~ type_spec  // scalar with type (also handles &[T] via type_spec)
+}
+
+// Typed variable declaration list: comma-separated typed declarations
 // Example: "x:i32, y:i32, z:i32"
-var_decl_list = {
-    var_decl ~ (comma ~ var_decl)*
+typed_var_decl_list = {
+    typed_var_decl ~ (comma ~ typed_var_decl)*
 }
 
 // Variable declaration: can be array or scalar, with or without type annotation
@@ -210,10 +217,10 @@ fn_decl = {
     | kw_fn ~ identifier ~ lparen ~ param_decl? ~ rparen
 }
 
-// Parameter declaration: list of parameter variables
+// Parameter declaration: list of parameter variables (types required)
 // Example: "x:i32, y:i32" in "fn add(x:i32, y:i32) -> i32 { }"
 param_decl = {
-    var_decl_list
+    typed_var_decl_list
 }
 
 // Function definition: declaration with implementation