openscad-parser 2.4.0__tar.gz → 2.4.1__tar.gz

{openscad_parser-2.4.0 → openscad_parser-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_parser
-Version: 2.4.0
+Version: 2.4.1
 Summary: A PEG parser to read OpenSCAD language source code, with optional AST tree generation.
 Keywords: openscad,openscad parser,parser
 Author: Revar Desmera
@@ -360,107 +360,129 @@ Parsing Library Files
 AST Node Types
 --------------
 
-The AST includes comprehensive node types for all OpenSCAD language constructs:
+The AST includes comprehensive node types for all OpenSCAD language constructs.
+All nodes inherit from ``ASTNode`` and carry ``position: Position`` and ``scope: Scope | None`` attributes.
 
 Base Classes
 ~~~~~~~~~~~~
 
-- ``ASTNode``: Base class for all AST nodes (includes ``position`` attribute)
+- ``ASTNode(position: Position, scope: Scope | None)``: Base class for all AST nodes
 - ``Expression``: Base class for all expression nodes
-- ``Primary``: Base class for atomic value types
+- ``Primary``: Base class for atomic value types (extends ``Expression``)
 - ``ModuleInstantiation``: Base class for module-related statements
+- ``VectorElement``: Base class for list comprehension elements
 
 Literals
 ~~~~~~~~
 
-- ``Identifier``: Variable, function, or module names
-- ``StringLiteral``: String values
-- ``NumberLiteral``: Numeric values
-- ``BooleanLiteral``: true/false values
-- ``UndefinedLiteral``: undef value
-- ``RangeLiteral``: Range expressions [start:end:step]
+- ``Identifier(name: str)``: Variable, function, or module names
+- ``StringLiteral(val: str)``: String values
+- ``NumberLiteral(val: float)``: Numeric values
+- ``BooleanLiteral(val: bool)``: true/false values
+- ``UndefinedLiteral``: The ``undef`` value (no additional fields)
+- ``RangeLiteral(start: Expression, end: Expression, step: Expression)``: Range expressions ``[start:step:end]``
 
 Operators
 ~~~~~~~~~
 
+All operators inherit from ``Expression`` and represent their respective operations with typed fields for operands. The AST preserves operator precedence and associativity as defined in OpenSCAD.
+
 Arithmetic:
-- ``AdditionOp``, ``SubtractionOp``, ``MultiplicationOp``, ``DivisionOp``
-- ``ModuloOp``, ``ExponentOp``, ``UnaryMinusOp``
+
+- ``AdditionOp(left: Expression, right: Expression)``:  represents ``left + right``
+- ``SubtractionOp(left: Expression, right: Expression)``:  represents ``left - right``
+- ``MultiplicationOp(left: Expression, right: Expression)``:  represents ``left * right``
+- ``DivisionOp(left: Expression, right: Expression)``:  represents ``left / right``
+- ``ModuloOp(left: Expression, right: Expression)``:  represents ``left % right``
+- ``ExponentOp(left: Expression, right: Expression)``:  represents ``left ^ right``
+- ``UnaryMinusOp(expr: Expression)``:  represents ``-expr``
 
 Logical:
-- ``LogicalAndOp``, ``LogicalOrOp``, ``LogicalNotOp``
+
+- ``LogicalAndOp(left: Expression, right: Expression)``:  represents ``left && right``
+- ``LogicalOrOp(left: Expression, right: Expression)``:  represents ``left || right``
+- ``LogicalNotOp(expr: Expression)``:  represents ``!expr``
 
 Comparison:
-- ``EqualityOp``, ``InequalityOp``
-- ``GreaterThanOp``, ``GreaterThanOrEqualOp``
-- ``LessThanOp``, ``LessThanOrEqualOp``
+
+- ``EqualityOp(left: Expression, right: Expression)``: represents ``left == right``
+- ``InequalityOp(left: Expression, right: Expression)``: represents ``left != right``
+- ``GreaterThanOp(left: Expression, right: Expression)``: represents ``left > right``
+- ``GreaterThanOrEqualOp(left: Expression, right: Expression)``: represents ``left >= right``
+- ``LessThanOp(left: Expression, right: Expression)``: represents ``left < right``
+- ``LessThanOrEqualOp(left: Expression, right: Expression)``: represents ``left <= right``
 
 Bitwise:
-- ``BitwiseAndOp``, ``BitwiseOrOp``, ``BitwiseNotOp``
-- ``BitwiseShiftLeftOp``, ``BitwiseShiftRightOp``
+
+- ``BitwiseAndOp(left: Expression, right: Expression)``: represents ``left & right``
+- ``BitwiseOrOp(left: Expression, right: Expression)``: represents ``left | right``
+- ``BitwiseShiftLeftOp(left: Expression, right: Expression)``: represents ``left << right``
+- ``BitwiseShiftRightOp(left: Expression, right: Expression)``: represents ``left >> right``
+- ``BitwiseNotOp(expr: Expression)``: represents ``~expr``
 
 Other:
-- ``TernaryOp``: condition ? true_expr : false_expr
+
+- ``TernaryOp(condition: Expression, true_expr: Expression, false_expr: Expression)``: Represents ``condition ? true_expr : false_expr``
 
 Expressions
 ~~~~~~~~~~~
 
-- ``LetOp``: let(assignments) body
-- ``EchoOp``: echo(arguments) body
-- ``AssertOp``: assert(arguments) body
-- ``FunctionLiteral``: function(parameters) body
-- ``PrimaryCall``: function calls
-- ``PrimaryIndex``: array indexing [index]
-- ``PrimaryMember``: member access .member
+- ``LetOp(assignments: list[Assignment], body: Expression)``: let clause  ``let(assignments) body``
+- ``EchoOp(arguments: list[Argument], body: Expression)``: echo clause  ``echo(arguments) body``
+- ``AssertOp(arguments: list[Argument], body: Expression)``: assert clause  ``assert(arguments) body``
+- ``FunctionLiteral(parameters: list[ParameterDeclaration], body: Expression)``: Anonymous function expression  ``function(parameters) body``
+- ``PrimaryCall(left: Expression, arguments: list[Argument])``: Function calls  ``left(arguments)``
+- ``PrimaryIndex(left: Expression, index: Expression)``: Array indexing ``left[index]``
+- ``PrimaryMember(left: Expression, member: Identifier)``: Member access ``left.member``
 
 List Comprehensions
 ~~~~~~~~~~~~~~~~~~~
 
-- ``ListComprehension``: Vector/list literals
-- ``ListCompFor``: for loops in list comprehensions
-- ``ListCompCFor``: C-style for loops
-- ``ListCompIf``, ``ListCompIfElse``: Conditionals
-- ``ListCompLet``: let expressions
-- ``ListCompEach``: each expressions
+- ``ListComprehension(elements: list[VectorElement])``: Vector/list literals ``[elements]``
+- ``ListCompFor(assignments: list[Assignment], body: VectorElement)``: for loops in list comprehensions ``for(assignments) body``
+- ``ListCompCFor(inits: list[Assignment], condition: Expression, incrs: list[Assignment], body: VectorElement)``: C-style for loops in list comprehensions ``for(inits; condition; incrs) body``
+- ``ListCompIf(condition: Expression, true_expr: VectorElement)``: Conditional inclusion without else ``if(condition) true_expr``
+- ``ListCompIfElse(condition: Expression, true_expr: VectorElement, false_expr: VectorElement)``: Conditional inclusion with else ``if(condition) true_expr else false_expr``
+- ``ListCompLet(assignments: list[Assignment], body: VectorElement)``: let expressions in list comprehensions ``let(assignments) body``
+- ``ListCompEach(body: VectorElement)``: each expressions (flattens nested lists) ``each body``
 
 Module Instantiations
 ~~~~~~~~~~~~~~~~~~~~~
 
-- ``ModularCall``: Module calls with arguments and children
-- ``ModularFor``: for loops
-- ``ModularCFor``: C-style for loops
-- ``ModularIntersectionFor``: intersection_for loops
-- ``ModularIntersectionCFor``: C-style intersection_for loops
-- ``ModularLet``: let statements
-- ``ModularEcho``: echo statements
-- ``ModularAssert``: assert statements
-- ``ModularIf``, ``ModularIfElse``: if/else statements
-- ``ModularModifierShowOnly``: ``!`` modifier
-- ``ModularModifierHighlight``: ``#`` modifier
-- ``ModularModifierBackground``: ``%`` modifier
-- ``ModularModifierDisable``: ``*`` modifier
+- ``ModularCall(name: Identifier, arguments: list[Argument], children: list[ModuleInstantiation])``: Module calls ``name(arguments) { children }``
+- ``ModularFor(assignments: list[Assignment], body: ModuleInstantiation)``: for loops in module bodies ``for(assignments) body``
+- ``ModularIntersectionFor(assignments: list[Assignment], body: ModuleInstantiation)``: intersection_for loops ``intersection_for(assignments) body``
+- ``ModularLet(assignments: list[Assignment], children: list[ModuleInstantiation])``: let statements in module bodies ``let(assignments) { children }``
+- ``ModularEcho(arguments: list[Argument], children: list[ModuleInstantiation])``: echo statements in module bodies ``echo(arguments) { children }``
+- ``ModularAssert(arguments: list[Argument], children: list[ModuleInstantiation])``: assert statements in module bodies ``assert(arguments) { children }``
+- ``ModularIf(condition: Expression, true_branch: ModuleInstantiation)``: if statements in module bodies, with no else ``if(condition) true_branch``
+- ``ModularIfElse(condition: Expression, true_branch: ModuleInstantiation, false_branch: ModuleInstantiation)``: if/else statements in module bodies ``if(condition) true_branch else false_branch``
+- ``ModularModifierShowOnly(child: ModuleInstantiation)``: Show-Only modifier ``!child``
+- ``ModularModifierHighlight(child: ModuleInstantiation)``: Highlight modifier ``#child``
+- ``ModularModifierBackground(child: ModuleInstantiation)``: Background modifier ``%child``
+- ``ModularModifierDisable(child: ModuleInstantiation)``: Disabler modifier ``*child``
 
 Declarations
 ~~~~~~~~~~~~
 
-- ``ModuleDeclaration``: module definitions
-- ``FunctionDeclaration``: function definitions
-- ``ParameterDeclaration``: function/module parameters
-- ``Assignment``: variable assignments
+- ``ModuleDeclaration(name: Identifier, parameters: list[ParameterDeclaration], children: list[ModuleInstantiation | Assignment | FunctionDeclaration | ModuleDeclaration])``: Module definitions ``module name(parameters) { children }``
+- ``FunctionDeclaration(name: Identifier, parameters: list[ParameterDeclaration], expr: Expression)``: Function definitions ``function name(parameters) = expr;``
+- ``ParameterDeclaration(name: Identifier, default: Expression | None)``: Function/module parameter with optional default value  ``name=default`` or ``name``
+- ``Assignment(name: Identifier, expr: Expression)``: Variable assignments ``name = expr;``
 
 Statements
 ~~~~~~~~~~
 
-- ``UseStatement``: use <filepath>
-- ``IncludeStatement``: include <filepath>
-- ``PositionalArgument``: Function call positional arguments
-- ``NamedArgument``: Function call named arguments (name=value)
+- ``UseStatement(filepath: StringLiteral)``: Represents ``use <filepath>``
+- ``IncludeStatement(filepath: StringLiteral)``: Represents ``include <filepath>``
+- ``PositionalArgument(expr: Expression)``: Function call positional arguments ``expr``
+- ``NamedArgument(name: Identifier, expr: Expression)``: Function call named arguments ``name=expr``
 
 Comments
 ~~~~~~~~
 
-- ``CommentLine``: Single-line comments //
-- ``CommentSpan``: Multi-line comments ``/* */``
+- ``CommentLine(text: str)``: Single-line comments ``// str``
+- ``CommentSpan(text: str)``: Multi-line comments ``/* str */``
 
 All AST node classes are fully documented with docstrings that include:
 - Description of what the node represents

{openscad_parser-2.4.0 → openscad_parser-2.4.1}/README.rst

@@ -317,107 +317,129 @@ Parsing Library Files
 AST Node Types
 --------------
 
-The AST includes comprehensive node types for all OpenSCAD language constructs:
+The AST includes comprehensive node types for all OpenSCAD language constructs.
+All nodes inherit from ``ASTNode`` and carry ``position: Position`` and ``scope: Scope | None`` attributes.
 
 Base Classes
 ~~~~~~~~~~~~
 
-- ``ASTNode``: Base class for all AST nodes (includes ``position`` attribute)
+- ``ASTNode(position: Position, scope: Scope | None)``: Base class for all AST nodes
 - ``Expression``: Base class for all expression nodes
-- ``Primary``: Base class for atomic value types
+- ``Primary``: Base class for atomic value types (extends ``Expression``)
 - ``ModuleInstantiation``: Base class for module-related statements
+- ``VectorElement``: Base class for list comprehension elements
 
 Literals
 ~~~~~~~~
 
-- ``Identifier``: Variable, function, or module names
-- ``StringLiteral``: String values
-- ``NumberLiteral``: Numeric values
-- ``BooleanLiteral``: true/false values
-- ``UndefinedLiteral``: undef value
-- ``RangeLiteral``: Range expressions [start:end:step]
+- ``Identifier(name: str)``: Variable, function, or module names
+- ``StringLiteral(val: str)``: String values
+- ``NumberLiteral(val: float)``: Numeric values
+- ``BooleanLiteral(val: bool)``: true/false values
+- ``UndefinedLiteral``: The ``undef`` value (no additional fields)
+- ``RangeLiteral(start: Expression, end: Expression, step: Expression)``: Range expressions ``[start:step:end]``
 
 Operators
 ~~~~~~~~~
 
+All operators inherit from ``Expression`` and represent their respective operations with typed fields for operands. The AST preserves operator precedence and associativity as defined in OpenSCAD.
+
 Arithmetic:
-- ``AdditionOp``, ``SubtractionOp``, ``MultiplicationOp``, ``DivisionOp``
-- ``ModuloOp``, ``ExponentOp``, ``UnaryMinusOp``
+
+- ``AdditionOp(left: Expression, right: Expression)``:  represents ``left + right``
+- ``SubtractionOp(left: Expression, right: Expression)``:  represents ``left - right``
+- ``MultiplicationOp(left: Expression, right: Expression)``:  represents ``left * right``
+- ``DivisionOp(left: Expression, right: Expression)``:  represents ``left / right``
+- ``ModuloOp(left: Expression, right: Expression)``:  represents ``left % right``
+- ``ExponentOp(left: Expression, right: Expression)``:  represents ``left ^ right``
+- ``UnaryMinusOp(expr: Expression)``:  represents ``-expr``
 
 Logical:
-- ``LogicalAndOp``, ``LogicalOrOp``, ``LogicalNotOp``
+
+- ``LogicalAndOp(left: Expression, right: Expression)``:  represents ``left && right``
+- ``LogicalOrOp(left: Expression, right: Expression)``:  represents ``left || right``
+- ``LogicalNotOp(expr: Expression)``:  represents ``!expr``
 
 Comparison:
-- ``EqualityOp``, ``InequalityOp``
-- ``GreaterThanOp``, ``GreaterThanOrEqualOp``
-- ``LessThanOp``, ``LessThanOrEqualOp``
+
+- ``EqualityOp(left: Expression, right: Expression)``: represents ``left == right``
+- ``InequalityOp(left: Expression, right: Expression)``: represents ``left != right``
+- ``GreaterThanOp(left: Expression, right: Expression)``: represents ``left > right``
+- ``GreaterThanOrEqualOp(left: Expression, right: Expression)``: represents ``left >= right``
+- ``LessThanOp(left: Expression, right: Expression)``: represents ``left < right``
+- ``LessThanOrEqualOp(left: Expression, right: Expression)``: represents ``left <= right``
 
 Bitwise:
-- ``BitwiseAndOp``, ``BitwiseOrOp``, ``BitwiseNotOp``
-- ``BitwiseShiftLeftOp``, ``BitwiseShiftRightOp``
+
+- ``BitwiseAndOp(left: Expression, right: Expression)``: represents ``left & right``
+- ``BitwiseOrOp(left: Expression, right: Expression)``: represents ``left | right``
+- ``BitwiseShiftLeftOp(left: Expression, right: Expression)``: represents ``left << right``
+- ``BitwiseShiftRightOp(left: Expression, right: Expression)``: represents ``left >> right``
+- ``BitwiseNotOp(expr: Expression)``: represents ``~expr``
 
 Other:
-- ``TernaryOp``: condition ? true_expr : false_expr
+
+- ``TernaryOp(condition: Expression, true_expr: Expression, false_expr: Expression)``: Represents ``condition ? true_expr : false_expr``
 
 Expressions
 ~~~~~~~~~~~
 
-- ``LetOp``: let(assignments) body
-- ``EchoOp``: echo(arguments) body
-- ``AssertOp``: assert(arguments) body
-- ``FunctionLiteral``: function(parameters) body
-- ``PrimaryCall``: function calls
-- ``PrimaryIndex``: array indexing [index]
-- ``PrimaryMember``: member access .member
+- ``LetOp(assignments: list[Assignment], body: Expression)``: let clause  ``let(assignments) body``
+- ``EchoOp(arguments: list[Argument], body: Expression)``: echo clause  ``echo(arguments) body``
+- ``AssertOp(arguments: list[Argument], body: Expression)``: assert clause  ``assert(arguments) body``
+- ``FunctionLiteral(parameters: list[ParameterDeclaration], body: Expression)``: Anonymous function expression  ``function(parameters) body``
+- ``PrimaryCall(left: Expression, arguments: list[Argument])``: Function calls  ``left(arguments)``
+- ``PrimaryIndex(left: Expression, index: Expression)``: Array indexing ``left[index]``
+- ``PrimaryMember(left: Expression, member: Identifier)``: Member access ``left.member``
 
 List Comprehensions
 ~~~~~~~~~~~~~~~~~~~
 
-- ``ListComprehension``: Vector/list literals
-- ``ListCompFor``: for loops in list comprehensions
-- ``ListCompCFor``: C-style for loops
-- ``ListCompIf``, ``ListCompIfElse``: Conditionals
-- ``ListCompLet``: let expressions
-- ``ListCompEach``: each expressions
+- ``ListComprehension(elements: list[VectorElement])``: Vector/list literals ``[elements]``
+- ``ListCompFor(assignments: list[Assignment], body: VectorElement)``: for loops in list comprehensions ``for(assignments) body``
+- ``ListCompCFor(inits: list[Assignment], condition: Expression, incrs: list[Assignment], body: VectorElement)``: C-style for loops in list comprehensions ``for(inits; condition; incrs) body``
+- ``ListCompIf(condition: Expression, true_expr: VectorElement)``: Conditional inclusion without else ``if(condition) true_expr``
+- ``ListCompIfElse(condition: Expression, true_expr: VectorElement, false_expr: VectorElement)``: Conditional inclusion with else ``if(condition) true_expr else false_expr``
+- ``ListCompLet(assignments: list[Assignment], body: VectorElement)``: let expressions in list comprehensions ``let(assignments) body``
+- ``ListCompEach(body: VectorElement)``: each expressions (flattens nested lists) ``each body``
 
 Module Instantiations
 ~~~~~~~~~~~~~~~~~~~~~
 
-- ``ModularCall``: Module calls with arguments and children
-- ``ModularFor``: for loops
-- ``ModularCFor``: C-style for loops
-- ``ModularIntersectionFor``: intersection_for loops
-- ``ModularIntersectionCFor``: C-style intersection_for loops
-- ``ModularLet``: let statements
-- ``ModularEcho``: echo statements
-- ``ModularAssert``: assert statements
-- ``ModularIf``, ``ModularIfElse``: if/else statements
-- ``ModularModifierShowOnly``: ``!`` modifier
-- ``ModularModifierHighlight``: ``#`` modifier
-- ``ModularModifierBackground``: ``%`` modifier
-- ``ModularModifierDisable``: ``*`` modifier
+- ``ModularCall(name: Identifier, arguments: list[Argument], children: list[ModuleInstantiation])``: Module calls ``name(arguments) { children }``
+- ``ModularFor(assignments: list[Assignment], body: ModuleInstantiation)``: for loops in module bodies ``for(assignments) body``
+- ``ModularIntersectionFor(assignments: list[Assignment], body: ModuleInstantiation)``: intersection_for loops ``intersection_for(assignments) body``
+- ``ModularLet(assignments: list[Assignment], children: list[ModuleInstantiation])``: let statements in module bodies ``let(assignments) { children }``
+- ``ModularEcho(arguments: list[Argument], children: list[ModuleInstantiation])``: echo statements in module bodies ``echo(arguments) { children }``
+- ``ModularAssert(arguments: list[Argument], children: list[ModuleInstantiation])``: assert statements in module bodies ``assert(arguments) { children }``
+- ``ModularIf(condition: Expression, true_branch: ModuleInstantiation)``: if statements in module bodies, with no else ``if(condition) true_branch``
+- ``ModularIfElse(condition: Expression, true_branch: ModuleInstantiation, false_branch: ModuleInstantiation)``: if/else statements in module bodies ``if(condition) true_branch else false_branch``
+- ``ModularModifierShowOnly(child: ModuleInstantiation)``: Show-Only modifier ``!child``
+- ``ModularModifierHighlight(child: ModuleInstantiation)``: Highlight modifier ``#child``
+- ``ModularModifierBackground(child: ModuleInstantiation)``: Background modifier ``%child``
+- ``ModularModifierDisable(child: ModuleInstantiation)``: Disabler modifier ``*child``
 
 Declarations
 ~~~~~~~~~~~~
 
-- ``ModuleDeclaration``: module definitions
-- ``FunctionDeclaration``: function definitions
-- ``ParameterDeclaration``: function/module parameters
-- ``Assignment``: variable assignments
+- ``ModuleDeclaration(name: Identifier, parameters: list[ParameterDeclaration], children: list[ModuleInstantiation | Assignment | FunctionDeclaration | ModuleDeclaration])``: Module definitions ``module name(parameters) { children }``
+- ``FunctionDeclaration(name: Identifier, parameters: list[ParameterDeclaration], expr: Expression)``: Function definitions ``function name(parameters) = expr;``
+- ``ParameterDeclaration(name: Identifier, default: Expression | None)``: Function/module parameter with optional default value  ``name=default`` or ``name``
+- ``Assignment(name: Identifier, expr: Expression)``: Variable assignments ``name = expr;``
 
 Statements
 ~~~~~~~~~~
 
-- ``UseStatement``: use <filepath>
-- ``IncludeStatement``: include <filepath>
-- ``PositionalArgument``: Function call positional arguments
-- ``NamedArgument``: Function call named arguments (name=value)
+- ``UseStatement(filepath: StringLiteral)``: Represents ``use <filepath>``
+- ``IncludeStatement(filepath: StringLiteral)``: Represents ``include <filepath>``
+- ``PositionalArgument(expr: Expression)``: Function call positional arguments ``expr``
+- ``NamedArgument(name: Identifier, expr: Expression)``: Function call named arguments ``name=expr``
 
 Comments
 ~~~~~~~~
 
-- ``CommentLine``: Single-line comments //
-- ``CommentSpan``: Multi-line comments ``/* */``
+- ``CommentLine(text: str)``: Single-line comments ``// str``
+- ``CommentSpan(text: str)``: Multi-line comments ``/* str */``
 
 All AST node classes are fully documented with docstrings that include:
 - Description of what the node represents

{openscad_parser-2.4.0 → openscad_parser-2.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "openscad_parser"
-version = "2.4.0"
+version = "2.4.1"
 description = "A PEG parser to read OpenSCAD language source code, with optional AST tree generation."
 readme = "README.rst"
 authors = [

{openscad_parser-2.4.0 → openscad_parser-2.4.1}/src/openscad_parser/ast/__init__.py

@@ -63,9 +63,7 @@ from .nodes import (
     ModuleInstantiation,
     ModularCall,
     ModularFor,
-    ModularCFor,
     ModularIntersectionFor,
-    ModularIntersectionCFor,
     ModularLet,
     ModularEcho,
     ModularAssert,

{openscad_parser-2.4.0 → openscad_parser-2.4.1}/src/openscad_parser/ast/builder.py

@@ -6,6 +6,28 @@ from .source_map import SourceMap
 from .nodes import *
 
 
+class _CForParts:
+    """Wrapper returned by c_for_inits/c_for_incrs visitors.
+
+    Always truthy so Arpeggio does not drop it from parent children when
+    there are zero assignments, and not a list so Arpeggio does not flatten
+    it into the parent's children list.
+    """
+    __slots__ = ('_items',)
+
+    def __init__(self, items: list) -> None:
+        self._items = items
+
+    def __iter__(self):
+        return iter(self._items)
+
+    def __len__(self) -> int:
+        return len(self._items)
+
+    def __bool__(self) -> bool:  # pragma: no cover
+        return True
+
+
 @dataclass
 class Position:
     """Represents a location in a source origin.
@@ -1051,7 +1073,9 @@ class ASTBuilderVisitor(PTNodeVisitor):
         return ListComprehension(elements=elements, position=self._get_node_position(node))
     
     def visit_funclit_def(self, node, children):
-        return FunctionLiteral(arguments=children[0], body=children[1], position=self._get_node_position(node))
+        parameters = [c for c in children if isinstance(c, ParameterDeclaration)]
+        body = next(c for c in children if not isinstance(c, ParameterDeclaration))
+        return FunctionLiteral(parameters=parameters, body=body, position=self._get_node_position(node))
     
     def visit_vector_elements(self, node, children):
         return list(children) if children else []
@@ -1066,24 +1090,43 @@ class ASTBuilderVisitor(PTNodeVisitor):
         return children[0]
     
     def visit_listcomp_let(self, node, children):
-        return ListCompLet(assignments=children[0], body=children[1], position=self._get_node_position(node))
-    
+        body = children[-1]
+        assignments = [c for c in children[:-1] if isinstance(c, Assignment)]
+        return ListCompLet(assignments=assignments, body=body, position=self._get_node_position(node))
+
     def visit_listcomp_each(self, node, children):
         return ListCompEach(body=children[0], position=self._get_node_position(node))
-    
+
     def visit_listcomp_for(self, node, children):
+        body = children[-1]
+        assignments = [c for c in children[:-1] if isinstance(c, Assignment)]
         return ListCompFor(
-            assignments=children[0],
-            body=children[1],
+            assignments=assignments,
+            body=body,
             position=self._get_node_position(node)
         )
 
+    def visit_c_for_inits(self, node, children):
+        return _CForParts([a for a in children if isinstance(a, Assignment)])
+
+    def visit_c_for_incrs(self, node, children):
+        return _CForParts([a for a in children if isinstance(a, Assignment)])
+
     def visit_listcomp_c_for(self, node, children):
+        idx = 0
+        inits = list(children[idx]) if isinstance(children[idx], _CForParts) else []
+        if isinstance(children[idx], _CForParts):
+            idx += 1
+        condition = children[idx]; idx += 1
+        incrs = list(children[idx]) if idx < len(children) and isinstance(children[idx], _CForParts) else []
+        if idx < len(children) and isinstance(children[idx], _CForParts):
+            idx += 1
+        body = children[idx]
         return ListCompCFor(
-            initial=children[0],
-            condition=children[1],
-            increment=children[2],
-            body=children[3],
+            inits=inits,
+            condition=condition,
+            incrs=incrs,
+            body=body,
             position=self._get_node_position(node)
         )
     
@@ -1123,56 +1166,32 @@ class ASTBuilderVisitor(PTNodeVisitor):
             position=self._get_node_position(node)
         )
     
-    def visit_modular_c_for(self, node, children):
-        initial = children[0] if isinstance(children[0], list) else [children[0]]
-        increment = children[2] if isinstance(children[2], list) else [children[2]]
-        body = children.get_rule('child_statement')
-        return ModularCFor(
-            initial=initial,
-            condition=children[1],
-            increment=increment,
-            body=body,
-            position=self._get_node_position(node)
-        )
-    
     def visit_modular_for(self, node, children):
-        assignments = children[0] if isinstance(children[0], list) else [children[0]]
+        assignments = [c for c in children if isinstance(c, Assignment)]
         body = children.get_rule('child_statement')
         return ModularFor(
             assignments=assignments,
             body=body,
             position=self._get_node_position(node)
         )
-    
-    def visit_modular_intersection_c_for(self, node, children):
-        initial = children[0] if isinstance(children[0], list) else [children[0]]
-        increment = children[2] if isinstance(children[2], list) else [children[2]]
-        body = children.get_rule('child_statement')
-        return ModularIntersectionCFor(
-            initial=initial,
-            condition=children[1],
-            increment=increment,
-            body=body,
-            position=self._get_node_position(node)
-        )
 
     def visit_modular_intersection_for(self, node, children):
-        assignments = children[0] if isinstance(children[0], list) else [children[0]]
+        assignments = [c for c in children if isinstance(c, Assignment)]
         body = children.get_rule('child_statement')
         return ModularIntersectionFor(assignments=assignments, body=body, position=self._get_node_position(node))
-    
+
     def visit_modular_let(self, node, children):
-        assignments = children[0] if isinstance(children[0], list) else [children[0]]
+        assignments = [c for c in children if isinstance(c, Assignment)]
         mods = children.get_rule('child_statement')
         return ModularLet(assignments=assignments, children=mods, position=self._get_node_position(node))
     
     def visit_modular_echo(self, node, children):
-        arguments = children[0] if isinstance(children[0], list) else [children[0]]
+        arguments = [c for c in children if isinstance(c, Argument)]
         mods = children.get_rule('child_statement')
         return ModularEcho(arguments=arguments, children=mods, position=self._get_node_position(node))
-    
+
     def visit_modular_assert(self, node, children):
-        arguments = children[0] if isinstance(children[0], list) else [children[0]]
+        arguments = [c for c in children if isinstance(c, Argument)]
         mods = children.get_rule('child_statement')
         return ModularAssert(arguments=arguments, children=mods, position=self._get_node_position(node))
     

{openscad_parser-2.4.0 → openscad_parser-2.4.1}/src/openscad_parser/ast/nodes.py

@@ -1061,35 +1061,30 @@ class LessThanOrEqualOp(Expression):
 @dataclass
 class FunctionLiteral(Expression):
     """Represents an OpenSCAD function literal (anonymous function).
-    
+
     Function literals are anonymous functions that can be assigned to variables
     or used directly in expressions. They are defined using the 'function' keyword.
-    
+
     Examples:
         x = function(x) x * 2;          // Anonymous function assigned to x
         function(a, b) a + b            // Function literal in expression
-    
+
     Attributes:
-        arguments: List of parameter declarations (as Argument nodes).
+        parameters: List of parameter declarations.
         body: The expression body of the function.
     """
-    arguments: list[Argument]
+    parameters: list[ParameterDeclaration]
     body: Expression
 
     def __str__(self):
-        return f"function({', '.join(str(arg) for arg in self.arguments)}) {self.body}"
+        return f"function({', '.join(str(p) for p in self.parameters)}) {self.body}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
         func_scope = parent_scope.child_scope()
-        # Normalize: builder may pass a single ParameterDeclaration for one-param literals
-        arguments = self.arguments
-        if not isinstance(arguments, (list, tuple)):
-            arguments = [arguments] if arguments is not None else []
-        for arg in arguments:
-            if isinstance(arg, ParameterDeclaration):
-                func_scope.define_variable(arg.name.name, arg)
-                arg.build_scope(func_scope)
+        for param in self.parameters:
+            func_scope.define_variable(param.name.name, param)
+            param.build_scope(func_scope)
         self.body.build_scope(func_scope)
 
 
@@ -1202,10 +1197,10 @@ class ListCompLet(VectorElement):
     
     Attributes:
         assignments: List of local variable assignments.
-        body: The expression body that uses the assigned variables.
+        body: The vector element body that uses the assigned variables.
     """
     assignments: list[Assignment]
-    body: Expression
+    body: VectorElement
 
     def __str__(self):
         return f"let ({', '.join(str(a) for a in self.assignments)}) {self.body}"
@@ -1213,11 +1208,7 @@ class ListCompLet(VectorElement):
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
         let_scope = parent_scope.child_scope()
-        # Normalize: builder may pass a single Assignment for one-binding lets
-        assignments = self.assignments
-        if not isinstance(assignments, (list, tuple)):
-            assignments = [assignments] if assignments is not None else []
-        for assignment in assignments:
+        for assignment in self.assignments:
             let_scope.define_variable(assignment.name.name, assignment)
             assignment.build_scope(let_scope)
         self.body.build_scope(let_scope)
@@ -1272,11 +1263,7 @@ class ListCompFor(VectorElement):
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
         for_scope = parent_scope.child_scope()
-        # Normalize: builder may pass a single Assignment for one-variable loops
-        assignments = self.assignments
-        if not isinstance(assignments, (list, tuple)):
-            assignments = [assignments] if assignments is not None else []
-        for assignment in assignments:
+        for assignment in self.assignments:
             assignment.scope = for_scope
             for_scope.define_variable(assignment.name.name, assignment)
             assignment.name.build_scope(for_scope)
@@ -1297,34 +1284,27 @@ class ListCompCFor(VectorElement):
         [i*2 for (i=0; i<10; i=i+2)]   // With increment step
     
     Attributes:
-        initial: List of initialization assignments.
+        inits: List of initialization assignments.
         condition: The loop continuation condition.
-        increment: List of increment assignments.
+        incrs: List of increment assignments.
         body: The expression to evaluate for each iteration.
     """
-    initial: list[Assignment]
+    inits: list[Assignment]
     condition: Expression
-    increment: list[Assignment]
+    incrs: list[Assignment]
     body: VectorElement
 
     def __str__(self):
-        return f"for ({', '.join(str(a) for a in self.initial)}; {self.condition}; {', '.join(str(a) for a in self.increment)}) {self.body}"
+        return f"for ({', '.join(str(a) for a in self.inits)}; {self.condition}; {', '.join(str(a) for a in self.incrs)}) {self.body}"
 
     def build_scope(self, parent_scope: "Scope") -> None:
         self.scope = parent_scope
         for_scope = parent_scope.child_scope()
-        # Normalize: builder may pass single Assignments
-        initial = self.initial
-        if not isinstance(initial, (list, tuple)):
-            initial = [initial] if initial is not None else []
-        increment = self.increment
-        if not isinstance(increment, (list, tuple)):
-            increment = [increment] if increment is not None else []
-        for assignment in initial:
+        for assignment in self.inits:
             for_scope.define_variable(assignment.name.name, assignment)
             assignment.build_scope(for_scope)
         self.condition.build_scope(for_scope)
-        for assignment in increment:
+        for assignment in self.incrs:
             assignment.build_scope(for_scope)
         self.body.build_scope(for_scope)
 
@@ -1496,46 +1476,6 @@ class ModularFor(ModuleInstantiation):
             node.build_scope(for_scope)
 
 
-@dataclass
-class ModularCFor(ModuleInstantiation):
-    """Represents a C-style for loop module instantiation.
-    
-    C-style for loops have three parts: initialization, condition, and increment.
-    Similar to C/Java for loops: for (init; condition; increment) body
-    
-    Examples:
-        for (i=0; i<5; i=i+1) translate([i, 0, 0]) cube(1);
-        for (i=0; i<10; i=i+2) rotate([0, 0, i]) cube(1);
-    
-    Attributes:
-        initial: List of initialization assignments.
-        condition: The loop continuation condition.
-        increment: List of increment assignments.
-        body: The module instantiation to execute for each iteration.
-    """
-    initial: list[Assignment]
-    condition: Expression
-    increment: list[Assignment]
-    body: ModuleInstantiation
-
-    def __str__(self):
-        return f"for ({'; '.join(str(a) for a in self.initial)}; {self.condition}; {', '.join(str(a) for a in self.increment)}) {self.body}"
-
-    def build_scope(self, parent_scope: "Scope") -> None:
-        self.scope = parent_scope
-        for_scope = parent_scope.child_scope()
-        for assignment in self.initial:
-            for_scope.define_variable(assignment.name.name, assignment)
-            assignment.build_scope(for_scope)
-        self.condition.build_scope(for_scope)
-        for assignment in self.increment:
-            assignment.build_scope(for_scope)
-        body = self.body if isinstance(self.body, list) else [self.body]
-        _collect_hoisted_declarations(body, for_scope)
-        for node in body:
-            node.build_scope(for_scope)
-
-
 @dataclass
 class ModularIntersectionFor(ModuleInstantiation):
     """Represents an intersection_for loop module instantiation.
@@ -1570,52 +1510,6 @@ class ModularIntersectionFor(ModuleInstantiation):
             node.build_scope(for_scope)
 
 
-@dataclass
-class ModularIntersectionCFor(ModuleInstantiation):
-    """Represents an intersection_for C-style loop module instantiation.
-
-    Similar to a C-style for loop, but computes the intersection of all
-    iterations rather than the union. Used for creating complex intersections
-    that use explicit initialization, condition, and increment.
-
-    Examples:
-        intersection_for(i = 0; i < 3; i = i + 1) rotate([0,0,i*90]) cube(10);
-
-    Attributes:
-        initial: List of initialization assignments.
-        condition: The loop continuation condition.
-        increment: List of increment assignments.
-        body: The module instantiation to execute for each iteration.
-    """
-    initial: list[Assignment]
-    condition: Expression
-    increment: list[Assignment]
-    body: ModuleInstantiation
-
-    def __str__(self):
-        return (
-            f"intersection_for ("
-            f"{'; '.join(str(a) for a in self.initial)}; "
-            f"{self.condition}; "
-            f"{', '.join(str(a) for a in self.increment)}"
-            f") {self.body}"
-        )
-
-    def build_scope(self, parent_scope: "Scope") -> None:
-        self.scope = parent_scope
-        for_scope = parent_scope.child_scope()
-        for assignment in self.initial:
-            for_scope.define_variable(assignment.name.name, assignment)
-            assignment.build_scope(for_scope)
-        self.condition.build_scope(for_scope)
-        for assignment in self.increment:
-            assignment.build_scope(for_scope)
-        body = self.body if isinstance(self.body, list) else [self.body]
-        _collect_hoisted_declarations(body, for_scope)
-        for node in body:
-            node.build_scope(for_scope)
-
-
 @dataclass
 class ModularLet(ModuleInstantiation):
     """Represents a let statement for module instantiations.

{openscad_parser-2.4.0 → openscad_parser-2.4.1}/src/openscad_parser/ast/pretty_print.py

@@ -4,8 +4,8 @@ from .nodes import (
     ASTNode, Assignment, FunctionDeclaration, ModuleDeclaration,
     UseStatement, IncludeStatement,
     ModuleInstantiation,
-    ModularCall, ModularFor, ModularCFor,
-    ModularIntersectionFor, ModularIntersectionCFor,
+    ModularCall, ModularFor,
+    ModularIntersectionFor,
     ModularLet, ModularEcho, ModularAssert,
     ModularIf, ModularIfElse,
     ModularModifierShowOnly, ModularModifierHighlight,
@@ -72,7 +72,7 @@ def _fmt_node(node: ASTNode, indent: int, w: int) -> str:
         return f"{pad}module {node.name}({params}) {block}"
     if isinstance(node, ModuleInstantiation):
         return _fmt_inst(node, indent, w)
-    return f"{pad}{node}"
+    return f"{pad}{node}"  # pragma: no cover
 
 
 def _fmt_block(nodes: list, indent: int, w: int) -> str:
@@ -129,20 +129,10 @@ def _fmt_inst(node: ModuleInstantiation, indent: int, w: int, prefix: str = "")
         assigns = _join_str(_as_list(node.assignments))
         return f"{pad}{prefix}for ({assigns})" + _fmt_child(node.body, indent, w)
 
-    if isinstance(node, ModularCFor):
-        init = _join_str(_as_list(node.initial))
-        inc = _join_str(_as_list(node.increment))
-        return f"{pad}{prefix}for ({init}; {node.condition}; {inc})" + _fmt_child(node.body, indent, w)
-
     if isinstance(node, ModularIntersectionFor):
         assigns = _join_str(_as_list(node.assignments))
         return f"{pad}{prefix}intersection_for ({assigns})" + _fmt_child(node.body, indent, w)
 
-    if isinstance(node, ModularIntersectionCFor):
-        init = _join_str(_as_list(node.initial))
-        inc = _join_str(_as_list(node.increment))
-        return f"{pad}{prefix}intersection_for ({init}; {node.condition}; {inc})" + _fmt_child(node.body, indent, w)
-
     if isinstance(node, ModularLet):
         assigns = _join_str(_as_list(node.assignments))
         return f"{pad}{prefix}let ({assigns})" + _fmt_child(node.children, indent, w)
@@ -166,4 +156,4 @@ def _fmt_inst(node: ModuleInstantiation, indent: int, w: int, prefix: str = "")
         connector = " else" if true_tail.startswith(" {") else f"\n{pad}else"
         return header + true_tail + connector + false_tail
 
-    return f"{pad}{prefix}{node};"
+    return f"{pad}{prefix}{node};"  # pragma: no cover

{openscad_parser-2.4.0 → openscad_parser-2.4.1}/src/openscad_parser/ast/serialization.py

@@ -76,9 +76,7 @@ from .nodes import (
     ModuleInstantiation,
     ModularCall,
     ModularFor,
-    ModularCFor,
     ModularIntersectionFor,
-    ModularIntersectionCFor,
     ModularLet,
     ModularEcho,
     ModularAssert,
@@ -157,9 +155,7 @@ _NODE_REGISTRY: dict[str, type[ASTNode]] = {
         # Module instantiations
         ModularCall,
         ModularFor,
-        ModularCFor,
         ModularIntersectionFor,
-        ModularIntersectionCFor,
         ModularLet,
         ModularEcho,
         ModularAssert,

{openscad_parser-2.4.0 → openscad_parser-2.4.1}/src/openscad_parser/cli.py

@@ -72,7 +72,7 @@ def main():
     elif args.yaml:
         try:
             from openscad_parser.ast import ast_to_yaml
-        except ImportError:
+        except ImportError:  # pragma: no cover
             print("openscad-parser: --yaml requires PyYAML (pip install openscad_parser[yaml])", file=sys.stderr)
             sys.exit(1)
         print(ast_to_yaml(ast))
@@ -80,5 +80,5 @@ def main():
         print(ast_to_json(ast, indent=args.indent))
 
 
-if __name__ == "__main__":
+if __name__ == "__main__":  # pragma: no cover
     main()

{openscad_parser-2.4.0 → openscad_parser-2.4.1}/src/openscad_parser/grammar.py

@@ -384,9 +384,7 @@ def ifelse_statement():
 
 def single_module_instantiation():
     return [
-            modular_c_for,
             modular_for,
-            modular_intersection_c_for,
             modular_intersection_for,
             modular_let,
             modular_assert,
@@ -409,36 +407,16 @@ def modular_for():
     return (KWD_FOR, TOK_PAREN, assignments_expr, TOK_ENDPAREN, child_statement)
 
 
-def modular_c_for():
-    return (
-        KWD_FOR,
-        TOK_PAREN,
-        assignments_expr,
-        TOK_SEMICOLON,
-        expr,
-        TOK_SEMICOLON,
-        assignments_expr,
-        TOK_ENDPAREN,
-        child_statement
-    )
+def c_for_inits():
+    return assignments_expr
 
 
-def modular_intersection_for():
-    return (KWD_INTERSECTION_FOR, TOK_PAREN, assignments_expr, TOK_ENDPAREN, child_statement)
+def c_for_incrs():
+    return assignments_expr
 
 
-def modular_intersection_c_for():
-    return (
-        KWD_INTERSECTION_FOR,
-        TOK_PAREN,
-        assignments_expr,
-        TOK_SEMICOLON,
-        expr,
-        TOK_SEMICOLON,
-        assignments_expr,
-        TOK_ENDPAREN,
-        child_statement
-    )
+def modular_intersection_for():
+    return (KWD_INTERSECTION_FOR, TOK_PAREN, assignments_expr, TOK_ENDPAREN, child_statement)
 
 
 def modular_let():
@@ -686,7 +664,7 @@ def listcomp_for():
 
 
 def listcomp_c_for():
-    return (KWD_FOR, TOK_PAREN, assignments_expr, TOK_SEMICOLON, expr, TOK_SEMICOLON, assignments_expr, TOK_ENDPAREN, vector_element)
+    return (KWD_FOR, TOK_PAREN, c_for_inits, TOK_SEMICOLON, expr, TOK_SEMICOLON, c_for_incrs, TOK_ENDPAREN, vector_element)
 
 
 def listcomp_ifonly():