Refactor parse utilities into dedicated modules

docs/complexity-antipatterns-and-refactoring-strategies.md

@@ -264,7 +264,9 @@ engineering principles from the outset.
 
 6. **Return Early / Guard Clauses:** To avoid deep nesting for validation or
    pre-condition checks, process exceptional cases first and return early.8
-   This approach flattens the main logic path and reduces nesting. For example, instead of:
+   This approach flattens the main logic path and reduces nesting. For example,
+   instead of:
+
    ```cpp
    void process(Data d) {
        if (d.isValid()) { // +1 (if)

docs/function-parsing-design.md

@@ -50,7 +50,7 @@ reached.
 Missing colons between a parameter name and type trigger
 `ParseError::MissingColon`. The span of the terminating comma or parenthesis is
 attached, so diagnostics point at the error. Helper functions
-`collect_parameter_name` and `finalise_parameter` keep the main loop small.
+`collect_parameter_name` and `ParameterBuilder` keep the main loop small.
 
 Empty names and types are reported with `ParseError::MissingName` and
 `ParseError::MissingType`. Both `collect_parameter_name` and `parse_type_expr`

src/parser/ast/mod.rs

@@ -7,6 +7,7 @@
 
 use rowan::SyntaxElement;
 
+use self::parse_utils::is_trivia;
 use crate::{DdlogLanguage, SyntaxKind};
 
 #[cfg_attr(
@@ -100,12 +101,13 @@ fn take_first_ident(
 ) -> Option<String> {
     use rowan::NodeOrToken;
     for e in iter {
+        if is_trivia(&e) {
+            continue;
+        }
         match e {
             NodeOrToken::Token(t) if t.kind() == SyntaxKind::T_IDENT => {
                 return Some(t.text().to_string());
             }
-            NodeOrToken::Token(t)
-                if matches!(t.kind(), SyntaxKind::T_WHITESPACE | SyntaxKind::T_COMMENT) => {}
             _ => return None,
         }
     }
@@ -120,10 +122,7 @@ pub(super) fn skip_whitespace_and_comments<I>(iter: &mut std::iter::Peekable<I>)
 where
     I: Iterator<Item = SyntaxElement<DdlogLanguage>>,
 {
-    while matches!(
-        iter.peek().map(SyntaxElement::kind),
-        Some(SyntaxKind::T_WHITESPACE | SyntaxKind::T_COMMENT)
-    ) {
+    while matches!(iter.peek(), Some(e) if is_trivia(e)) {
         iter.next();
     }
 }

src/parser/ast/parse_utils/errors.rs

@@ -1,8 +1,8 @@
 //! Error types and helpers for delimiter tracking during type parsing.
 //!
-//! The functions in `type_parsing` rely on these structures to report
-//! mismatched or unclosed delimiters when reading parameter lists and type
-//! expressions.
+//! The functions in `params`, `outputs`, and `type_expr` rely on these
+//! structures to report mismatched or unclosed delimiters when reading
+//! parameter lists and type expressions.
 
 use rowan::TextRange;
 

src/parser/ast/parse_utils/mod.rs

@@ -1,17 +1,23 @@
 //! Parsing helpers shared across AST modules.
 //!
 //! This module provides small utilities for collecting parameter names and
-//! types from the CST and for recursively parsing type expressions. Both the
-//! `Function` and `Relation` nodes import these helpers so they can share the
-//! same logic when interpreting their declarations. See
+//! types from the CST, recursively parsing type expressions, and parsing
+//! transformer output identifiers. `Function`, `Relation`, and `Transformer`
+//! nodes import these helpers so they can share the same logic when
+//! interpreting their declarations. See
 //! `docs/function-parsing-design.md` for an overview.
 
 mod delimiter;
 pub(crate) mod errors;
+mod outputs;
+mod params;
 mod token_utils;
-mod type_parsing;
+mod type_expr;
 
 pub use delimiter::extract_parenthesized;
 pub(crate) use delimiter::paren_block_span;
 
-pub(crate) use type_parsing::{parse_name_type_pairs, parse_output_list, parse_type_after_colon};
+pub(crate) use outputs::parse_output_list;
+pub(crate) use params::parse_name_type_pairs;
+pub(crate) use token_utils::is_trivia;
+pub(crate) use type_expr::parse_type_after_colon;

src/parser/ast/parse_utils/outputs.rs

@@ -0,0 +1,97 @@
+//! Output list parsing utilities.
+//!
+//! Parses comma-separated output relation names following a transformer
+//! declaration's colon.
+
+use rowan::SyntaxElement;
+
+use crate::{DdlogLanguage, SyntaxKind};
+
+use super::super::skip_whitespace_and_comments;
+
+pub(crate) fn skip_to_top_level_colon<I>(iter: &mut std::iter::Peekable<I>)
+where
+    I: Iterator<Item = SyntaxElement<DdlogLanguage>>,
+{
+    let mut depth = 0usize;
+    for e in iter.by_ref() {
+        match e.kind() {
+            SyntaxKind::T_LPAREN => depth += 1,
+            SyntaxKind::T_RPAREN => depth = depth.saturating_sub(1),
+            SyntaxKind::T_COLON if depth == 0 => break,
+            _ => {}
+        }
+    }
+}
+
+fn try_parse_identifier<I>(iter: &mut std::iter::Peekable<I>) -> Option<String>
+where
+    I: Iterator<Item = SyntaxElement<DdlogLanguage>>,
+{
+    use rowan::NodeOrToken;
+
+    skip_whitespace_and_comments(iter);
+    match iter.next() {
+        Some(NodeOrToken::Token(t)) if t.kind() == SyntaxKind::T_IDENT => {
+            Some(t.text().to_string())
+        }
+        _ => None,
+    }
+}
+
+fn has_comma_separator<I>(iter: &mut std::iter::Peekable<I>) -> bool
+where
+    I: Iterator<Item = SyntaxElement<DdlogLanguage>>,
+{
+    use rowan::NodeOrToken;
+
+    skip_whitespace_and_comments(iter);
+    if let Some(NodeOrToken::Token(t)) = iter.peek()
+        && t.kind() == SyntaxKind::T_COMMA
+    {
+        iter.next();
+        true
+    } else {
+        false
+    }
+}
+
+pub(crate) fn parse_output_list<I>(iter: I) -> Vec<String>
+where
+    I: Iterator<Item = SyntaxElement<DdlogLanguage>>,
+{
+    let mut iter = iter.peekable();
+    skip_to_top_level_colon(&mut iter);
+
+    let mut names = Vec::new();
+    while let Some(name) = try_parse_identifier(&mut iter) {
+        names.push(name);
+        if !has_comma_separator(&mut iter) {
+            break;
+        }
+    }
+
+    names
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::parser::ast::AstNode;
+    use crate::parser::parse;
+
+    #[test]
+    fn collects_output_names() {
+        let src = "extern transformer t(a: X): Out1, Out2";
+        let parsed = parse(src);
+        #[expect(clippy::expect_used, reason = "Using expect for clearer test failures")]
+        let tr = parsed
+            .root()
+            .transformers()
+            .first()
+            .cloned()
+            .expect("transformer missing");
+        let names = parse_output_list(tr.syntax().children_with_tokens());
+        assert_eq!(names, vec!["Out1".to_string(), "Out2".to_string()]);
+    }
+}