refactor(parser): audit-driven cleanup — dead code, DRY helpers, decompose primary.rs

Delete ~360 lines of dead code (parse_method, parse_impl_function,
parse_binding_pattern, parse_variable_assignment, entire comptime.rs).

Add core helpers: try_split_right_angle (consolidate >> splitting),
parse_dotted_path, parse_identifier_list, AstType::self_type().

Rewrite external.rs with core helpers (85→59 lines), replace manual
save/restore with save_state()/restore_state(), consolidate method-chain
parsing into calls.rs, decompose 800-line parse_primary_expression into
thin dispatch + helpers, replace boolean-tuple DeclKind with enum.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: lantos1618

src/ast/types.rs

@@ -133,6 +133,15 @@ pub struct TraitConstraint {
 // ============================================================================
 
 impl AstType {
+    /// Create a Self-type placeholder for implicit `self` parameters.
+    /// This is resolved during type checking based on the implementing type.
+    pub fn self_type() -> AstType {
+        AstType::Generic {
+            name: "Self".to_string(),
+            type_args: Vec::new(),
+        }
+    }
+
     /// Returns the variant name of this type as a static string.
     pub fn variant_name(&self) -> &'static str {
         match self {

src/parser/behaviors.rs

@@ -70,10 +70,7 @@ impl<'a> Parser<'a> {
         let type_ = if name == "self" && self.current_token != Token::Symbol(':') {
             // For 'self' without explicit type, use a placeholder type
             // This will be resolved during type checking based on the implementing type
-            Type::Generic {
-                name: "Self".to_string(),
-                type_args: Vec::new(),
-            }
+            Type::self_type()
         } else {
             // Expect ':' for type annotation
             self.expect_symbol(':')?;
@@ -263,94 +260,7 @@ impl<'a> Parser<'a> {
                 let param_type = if param_name == "self" && self.current_token != Token::Symbol(':')
                 {
                     // For 'self' without explicit type, use a placeholder type
-                    Type::Generic {
-                        name: "Self".to_string(),
-                        type_args: Vec::new(),
-                    }
-                } else {
-                    self.expect_symbol(':')?;
-                    self.parse_type()?
-                };
-                args.push((param_name, param_type));
-
-                if self.current_token == Token::Symbol(')') {
-                    break;
-                }
-                if !self.try_consume_symbol(',') {
-                    return Err(self.syntax_error("Expected ',' or ')' in parameter list"));
-                }
-            }
-        }
-        self.next_token(); // consume ')'
-
-        // Check for return type (it should be present for impl functions)
-        let return_type = if self.current_token != Token::Symbol('{') {
-            // If it's not '{', then we have a return type
-            self.parse_type()?
-        } else {
-            // Default to void/unit type if no return type specified
-            crate::ast::AstType::Void
-        };
-
-        // Function body
-        self.expect_symbol('{')?;
-
-        let mut body = vec![];
-        while self.current_token != Token::Symbol('}') && self.current_token != Token::Eof {
-            body.push(self.parse_statement()?);
-        }
-
-        if self.current_token != Token::Symbol('}') {
-            return Err(self.syntax_error("Expected '}' to close function body"));
-        }
-        self.next_token();
-
-        // Check visibility before moving name
-        let is_public = !name.starts_with("__");
-
-        Ok(Function {
-            name,
-            type_params,
-            args,
-            return_type,
-            body,
-            is_varargs: false,
-            is_public,
-        })
-    }
-
-    /// Parse a function within an impl block context
-    /// This is different from parse_function() because the function name and '=' have already been consumed
-    #[allow(dead_code)]
-    pub fn parse_impl_function(&mut self) -> Result<crate::ast::Function> {
-        use crate::ast::Function;
-
-        // Function name
-        let name = self.expect_identifier("function name")?;
-
-        // Parse generic type parameters if present: <T: Constraint, U, ...>
-        let type_params = self.parse_type_parameters()?;
-
-        // Expect '=' (function signature separator)
-        self.expect_operator("=")?;
-
-        // Parameters
-        self.expect_symbol('(')?;
-
-        let mut args = vec![];
-        if self.current_token != Token::Symbol(')') {
-            loop {
-                // Parameter name
-                let param_name = self.expect_identifier("parameter name")?;
-
-                // Parameter type - special handling for 'self'
-                let param_type = if param_name == "self" && self.current_token != Token::Symbol(':')
-                {
-                    // For 'self' without explicit type, use a placeholder type
-                    Type::Generic {
-                        name: "Self".to_string(),
-                        type_args: Vec::new(),
-                    }
+                    Type::self_type()
                 } else {
                     self.expect_symbol(':')?;
                     self.parse_type()?

src/parser/comptime.rs

@@ -69,28 +69,29 @@ impl<'a> Parser<'a> {
         }
     }
 
+    /// Try to split a `>>` or `>>=` token by consuming one `>`.
+    /// Returns true if successfully consumed a `>` (either standalone or by splitting).
+    /// Does NOT advance past a standalone `>` — that's done by the caller.
+    fn try_split_right_angle(&mut self) -> bool {
+        if self.current_token == Token::Operator(">>".to_string()) {
+            self.current_token = Token::Operator(">".to_string());
+            true
+        } else if self.current_token == Token::Operator(">>=".to_string()) {
+            self.current_token = Token::Operator(">=".to_string());
+            true
+        } else {
+            false
+        }
+    }
+
     /// Expect current token to be a specific operator, return error if not
     /// Special handling for `>` when current token is `>>` or `>>=` (needed for nested generics)
     pub fn expect_operator(&mut self, expected: &str) -> crate::error::Result<()> {
         if self.current_token == Token::Operator(expected.to_string()) {
             self.next_token();
             Ok(())
-        } else if expected == ">" {
-            // Handle nested generics: when expecting `>`, split `>>` into two `>` tokens
-            if self.current_token == Token::Operator(">>".to_string()) {
-                // Replace `>>` with single `>` (the remaining part after consuming one `>`)
-                self.current_token = Token::Operator(">".to_string());
-                Ok(())
-            } else if self.current_token == Token::Operator(">>=".to_string()) {
-                // Replace `>>=` with `>=` (the remaining part after consuming one `>`)
-                self.current_token = Token::Operator(">=".to_string());
-                Ok(())
-            } else {
-                Err(self.syntax_error(format!(
-                    "Expected '{}', got {:?}",
-                    expected, self.current_token
-                )))
-            }
+        } else if expected == ">" && self.try_split_right_angle() {
+            Ok(())
         } else {
             Err(self.syntax_error(format!(
                 "Expected '{}', got {:?}",
@@ -115,21 +116,8 @@ impl<'a> Parser<'a> {
         if self.current_token == Token::Operator(op.to_string()) {
             self.next_token();
             true
-        } else if op == ">" {
-            // Handle nested generics: when looking for `>`, split `>>` into two `>` tokens
-            if self.current_token == Token::Operator(">>".to_string()) {
-                // Replace `>>` with single `>` (the remaining part after consuming one `>`)
-                self.current_token = Token::Operator(">".to_string());
-                true
-            } else if self.current_token == Token::Operator(">>=".to_string()) {
-                // Replace `>>=` with `>=` (the remaining part after consuming one `>`)
-                self.current_token = Token::Operator(">=".to_string());
-                true
-            } else {
-                false
-            }
         } else {
-            false
+            op == ">" && self.try_split_right_angle()
         }
     }
 
@@ -187,14 +175,8 @@ impl<'a> Parser<'a> {
             if self.current_token == Token::Symbol(',') {
                 result.push(',');
                 self.next_token();
-            } else if self.current_token == Token::Operator(">".to_string()) {
+            } else if self.try_consume_operator(">") {
                 result.push('>');
-                self.next_token();
-                break;
-            } else if self.current_token == Token::Operator(">>".to_string()) {
-                // Handle nested generics: split `>>` into `>` + `>`
-                result.push('>');
-                self.current_token = Token::Operator(">".to_string());
                 break;
             } else {
                 break;
@@ -225,6 +207,48 @@ impl<'a> Parser<'a> {
         }
     }
 
+    /// Parse a dotted identifier path: `initial.member1.member2...`
+    /// Consumes `.identifier` pairs as long as they're available.
+    pub fn parse_dotted_path(&mut self, initial: String) -> String {
+        let mut path = initial;
+        while self.current_token == Token::Symbol('.') {
+            self.next_token();
+            if let Token::Identifier(member) = &self.current_token {
+                path.push('.');
+                path.push_str(member);
+                self.next_token();
+            } else {
+                break;
+            }
+        }
+        path
+    }
+
+    /// Parse a comma-separated list of identifiers enclosed by `close` char.
+    /// Assumes the opening delimiter has already been consumed.
+    /// Consumes the closing delimiter.
+    pub fn parse_identifier_list(
+        &mut self,
+        close: char,
+        context: &str,
+    ) -> crate::error::Result<Vec<String>> {
+        let mut names = vec![];
+        while self.current_token != Token::Symbol(close) && self.current_token != Token::Eof {
+            let name = self.expect_identifier(context)?;
+            names.push(name);
+            if !self.try_consume_symbol(',') && self.current_token != Token::Symbol(close) {
+                return Err(
+                    self.syntax_error(format!("Expected ',' or '{}' in {}", close, context))
+                );
+            }
+        }
+        if self.current_token != Token::Symbol(close) {
+            return Err(self.syntax_error(format!("Expected '{}' to close {}", close, context)));
+        }
+        self.next_token(); // consume close
+        Ok(names)
+    }
+
     // ========================================================================
     // STATE SAVE/RESTORE FOR LOOK-AHEAD
     // ========================================================================