fluent-codegen 0.2__tar.gz → 0.3.0__tar.gz

{fluent_codegen-0.2/src/fluent_codegen.egg-info → fluent_codegen-0.3.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: fluent-codegen
-Version: 0.2
+Version: 0.3.0
 Summary: A Python library for generating Python code via AST construction.
 Author-email: Luke Plant <luke@lukeplant.me.uk>
 License-Expression: Apache-2.0
 Project-URL: Repository, https://github.com/spookylukey/fluent-codegen
 Keywords: codegen,code-generation,ast,python,metaprogramming
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3 :: Only

{fluent_codegen-0.2 → fluent_codegen-0.3.0}/pyproject.toml

@@ -14,7 +14,7 @@ keywords = [
   "metaprogramming",
 ]
 classifiers = [
-  "Development Status :: 3 - Alpha",
+  "Development Status :: 4 - Beta",
   "Intended Audience :: Developers",
   "Operating System :: OS Independent",
   "Programming Language :: Python :: 3 :: Only",
@@ -24,7 +24,7 @@ classifiers = [
   "Topic :: Software Development :: Code Generators",
   "Topic :: Software Development :: Libraries :: Python Modules",
 ]
-version = "0.2"
+version = "0.3.0"
 dependencies = []
 
 [project.urls]
@@ -74,7 +74,7 @@ dev = [
     "pyright==1.1.406",
     "pytest>=7.4.4",
     "pytest-cov>=7.0.0",
-    "ruff>=0.4.0",
+    "ruff>=0.15.1",
     "tox>=4.36.0",
     "tox-uv>=1.29.0",
 ]

{fluent_codegen-0.2 → fluent_codegen-0.3.0}/src/fluent_codegen/codegen.py

@@ -10,7 +10,7 @@ import keyword
 import re
 import textwrap
 from abc import ABC, abstractmethod
-from collections.abc import Callable, Sequence
+from collections.abc import Callable, Mapping, Sequence
 from dataclasses import dataclass
 from typing import ClassVar, Protocol, assert_never, overload, runtime_checkable
 
@@ -102,8 +102,6 @@ class CodeGenAst(ABC):
     @abstractmethod
     def as_ast(self, *, include_comments: bool = False) -> py_ast.AST: ...
 
-    child_elements: ClassVar[list[str]]
-
     def as_python_source(self) -> str:
         """Return the Python source code for this AST node."""
         node = self.as_ast(include_comments=True)
@@ -120,8 +118,6 @@ class CodeGenAstList(ABC):
     @abstractmethod
     def as_ast_list(self, allow_empty: bool = True, *, include_comments: bool = False) -> list[py_ast.stmt]: ...
 
-    child_elements: ClassVar[list[str]]
-
     def as_python_source(self) -> str:
         """Return the Python source code for this AST list."""
         mod = py_ast.Module(body=self.as_ast_list(include_comments=True), type_ignores=[], **DEFAULT_AST_ARGS_MODULE)
@@ -258,11 +254,9 @@ class SupportsNameAssignment(Protocol):
     def has_assignment_for_name(self, name: str) -> bool: ...
 
 
-class _Annotation(Statement):
+class Annotation(Statement):
     """A bare type annotation without a value, e.g. ``x: int``."""
 
-    child_elements = []
-
     def __init__(self, name: str, annotation: Expression):
         self.name = name
         self.annotation = annotation
@@ -282,9 +276,7 @@ class _Annotation(Statement):
         return self.name == name
 
 
-class _Assignment(Statement):
-    child_elements = ["value"]
-
+class Assignment(Statement):
     def __init__(self, name: str, value: Expression, /, *, type_hint: Expression | None = None):
         self.name = name
         self.value = value
@@ -313,8 +305,6 @@ class _Assignment(Statement):
 
 
 class Block(CodeGenAstList):
-    child_elements = ["statements"]
-
     def __init__(self, scope: Scope, parent_block: Block | None = None):
         self.scope = scope
         # We allow `Expression` here for things like MethodCall which
@@ -459,7 +449,7 @@ class Block(CodeGenAstList):
         else:
             self.scope.register_assignment(name)
 
-        self.add_statement(_Assignment(name, value, type_hint=type_hint))
+        self.add_statement(Assignment(name, value, type_hint=type_hint))
 
     def create_annotation(self, name: str, annotation: Expression) -> Name:
         """
@@ -471,7 +461,7 @@ class Block(CodeGenAstList):
         """
         name_obj = self.scope.create_name(name)
         self.scope.register_assignment(name_obj.name)
-        self.add_statement(_Annotation(name_obj.name, annotation))
+        self.add_statement(Annotation(name_obj.name, annotation))
         return name_obj
 
     def create_field(self, name: str, annotation: Expression, *, default: Expression | None = None) -> Name:
@@ -489,7 +479,7 @@ class Block(CodeGenAstList):
         if default is not None:
             name_obj = self.scope.create_name(name)
             self.scope.register_assignment(name_obj.name)
-            self.add_statement(_Assignment(name_obj.name, default, type_hint=annotation))
+            self.add_statement(Assignment(name_obj.name, default, type_hint=annotation))
             return name_obj
         else:
             return self.create_annotation(name, annotation)
@@ -669,8 +659,6 @@ def _validate_arg_order(args: list[FunctionArg]) -> None:
 
 
 class Function(Scope, Statement):
-    child_elements = ["body"]
-
     def __init__(
         self,
         name: str,
@@ -688,6 +676,11 @@ class Function(Scope, Statement):
         if args is not None:
             self.add_args(args)
 
+    @property
+    def args(self) -> Sequence[FunctionArg]:
+        """Return the function's arguments as a read-only sequence."""
+        return tuple(self._args)
+
     def add_args(self, args: Sequence[str | FunctionArg]) -> None:
         """Add arguments to the function, with the same validation as in __init__."""
         normalized = _normalize_args(args)
@@ -750,8 +743,6 @@ class Function(Scope, Statement):
 
 
 class Class(Scope, Statement):
-    child_elements = ["body"]
-
     def __init__(
         self,
         name: str,
@@ -780,8 +771,6 @@ class Class(Scope, Statement):
 
 
 class Return(Statement):
-    child_elements = ["value"]
-
     def __init__(self, value: Expression):
         self.value = value
 
@@ -795,8 +784,6 @@ class Return(Statement):
 class Assert(Statement):
     """An ``assert`` statement with an optional message."""
 
-    child_elements = ["test", "msg"]
-
     def __init__(self, test: Expression, msg: Expression | None = None):
         self.test = test
         self.msg = msg
@@ -814,8 +801,6 @@ class Assert(Statement):
 
 
 class If(Statement):
-    child_elements = ["if_blocks", "conditions", "else_block"]
-
     def __init__(self, parent_scope: Scope, parent_block: Block | None = None):
         # We model a "compound if statement" as a list of if blocks
         # (if/elif/elif etc), each with their own condition, with a final else
@@ -867,8 +852,6 @@ class If(Statement):
 
 
 class With(Statement):
-    child_elements = ["context_expr", "body"]
-
     def __init__(
         self,
         context_expr: Expression,
@@ -901,8 +884,6 @@ class With(Statement):
 
 
 class Try(Statement):
-    child_elements = ["catch_exceptions", "try_block", "except_block", "else_block"]
-
     def __init__(self, catch_exceptions: Sequence[Expression], parent_scope: Scope):
         self.catch_exceptions = catch_exceptions
         self.try_block = Block(parent_scope)
@@ -1014,7 +995,7 @@ class Expression(CodeGenAst):
     def call(
         self,
         args: Sequence[Expression] | None = None,
-        kwargs: dict[str, Expression] | None = None,
+        kwargs: Mapping[str, Expression] | None = None,
     ) -> Call:
         return Call(self, args or [], kwargs or {})
 
@@ -1022,7 +1003,7 @@ class Expression(CodeGenAst):
         self,
         attribute: str,
         args: Sequence[Expression] | None = None,
-        kwargs: dict[str, Expression] | None = None,
+        kwargs: Mapping[str, Expression] | None = None,
     ) -> Call:
         return self.attr(attribute).call(args, kwargs)
 
@@ -1098,8 +1079,6 @@ class Expression(CodeGenAst):
 
 
 class String(Expression):
-    child_elements = []
-
     def __init__(self, string_value: str):
         self.string_value = string_value
 
@@ -1118,8 +1097,6 @@ class String(Expression):
 
 
 class Bool(Expression):
-    child_elements = []
-
     def __init__(self, value: bool):
         self.value = value
 
@@ -1131,8 +1108,6 @@ class Bool(Expression):
 
 
 class Bytes(Expression):
-    child_elements = []
-
     def __init__(self, value: bytes):
         self.value = value
 
@@ -1144,8 +1119,6 @@ class Bytes(Expression):
 
 
 class Number(Expression):
-    child_elements = []
-
     def __init__(self, number: int | float):
         self.number = number
 
@@ -1157,9 +1130,7 @@ class Number(Expression):
 
 
 class List(Expression):
-    child_elements = ["items"]
-
-    def __init__(self, items: list[Expression]):
+    def __init__(self, items: Sequence[Expression]):
         self.items = items
 
     def as_ast(self, *, include_comments: bool = False) -> py_ast.expr:
@@ -1167,8 +1138,6 @@ class List(Expression):
 
 
 class Tuple(Expression):
-    child_elements = ["items"]
-
     def __init__(self, items: Sequence[Expression]):
         self.items = items
 
@@ -1177,8 +1146,6 @@ class Tuple(Expression):
 
 
 class Set(Expression):
-    child_elements = ["items"]
-
     def __init__(self, items: Sequence[Expression]):
         self.items = items
 
@@ -1195,8 +1162,6 @@ class Set(Expression):
 
 
 class Dict(Expression):
-    child_elements = ["pairs"]
-
     def __init__(self, pairs: Sequence[tuple[Expression, Expression]]):
         self.pairs = pairs
 
@@ -1209,8 +1174,6 @@ class Dict(Expression):
 
 
 class StringJoinBase(Expression):
-    child_elements = ["parts"]
-
     def __init__(self, parts: Sequence[Expression]):
         self.parts = parts
 
@@ -1280,8 +1243,6 @@ StringJoin = FStringJoin
 
 
 class Name(Expression):
-    child_elements = []
-
     def __init__(self, name: str, scope: Scope):
         if not scope.is_name_in_use(name):
             raise AssertionError(f"Cannot refer to undefined name '{name}'")
@@ -1300,8 +1261,6 @@ class Name(Expression):
 
 
 class Attr(Expression):
-    child_elements = ["value"]
-
     def __init__(self, value: Expression, attribute: str) -> None:
         self.value = value
         if not allowable_name(attribute, allow_builtin=True):
@@ -1313,8 +1272,6 @@ class Attr(Expression):
 
 
 class Starred(Expression):
-    child_elements = ["value"]
-
     def __init__(self, value: Expression):
         self.value = value
 
@@ -1328,7 +1285,7 @@ class Starred(Expression):
 def function_call(
     function_name: str,
     args: Sequence[Expression],
-    kwargs: dict[str, Expression],
+    kwargs: Mapping[str, Expression],
     scope: Scope,
 ) -> Expression:
     if not scope.is_name_in_use(function_name):
@@ -1340,17 +1297,15 @@ def function_call(
 
 
 class Call(Expression):
-    child_elements = ["value", "args", "kwargs"]
-
     def __init__(
         self,
         value: Expression,
         args: Sequence[Expression],
-        kwargs: dict[str, Expression],
+        kwargs: Mapping[str, Expression],
     ):
         self.value = value
         self.args = list(args)
-        self.kwargs = kwargs
+        self.kwargs = dict(kwargs)
 
     def as_ast(self, *, include_comments: bool = False) -> py_ast.expr:
 
@@ -1406,14 +1361,12 @@ def method_call(
     obj: Expression,
     method_name: str,
     args: Sequence[Expression],
-    kwargs: dict[str, Expression],
+    kwargs: Mapping[str, Expression],
 ):
     return obj.attr(method_name).call(args=args, kwargs=kwargs)
 
 
 class Subscript(Expression):
-    child_elements = ["value", "slice"]
-
     def __init__(self, value: Expression, slice: Expression):
         self.value = value
         self.slice = slice
@@ -1436,8 +1389,6 @@ class NoneExpr(Expression):
 
 
 class BinaryOperator(Expression):
-    child_elements = ["left", "right"]
-
     def __init__(self, left: Expression, right: Expression):
         self.left = left
         self.right = right
@@ -1579,19 +1530,47 @@ def simplify(codegen_ast: CodeGenAstType, simplifier: Callable[[CodeGenAstType,
 def rewriting_traverse(
     node: CodeGenAstType | Sequence[CodeGenAstType],
     func: Callable[[CodeGenAstType], CodeGenAstType],
+    _visited: set[int] | None = None,
 ):
     """
-    Apply 'func' to node and all sub CodeGenAst nodes
+    Apply 'func' to node and all sub CodeGenAst nodes.
+
+    Discovers child nodes by introspecting instance attributes rather than
+    relying on a manually-maintained list.  A *visited* set (keyed by
+    ``id()``) prevents infinite recursion through circular references
+    (e.g. Block.scope → Function → body → Block).
     """
+    if _visited is None:
+        _visited = set()
     if isinstance(node, (CodeGenAst, CodeGenAstList)):
+        node_id = id(node)
+        if node_id in _visited:
+            return
+        _visited.add(node_id)
         new_node = func(node)
         if new_node is not node:
             morph_into(node, new_node)
-        for k in node.child_elements:
-            rewriting_traverse(getattr(node, k), func)
+        for value in node.__dict__.values():
+            _traverse_value(value, func, _visited)
     elif isinstance(node, (list, tuple)):
         for i in node:
-            rewriting_traverse(i, func)
+            rewriting_traverse(i, func, _visited)
+
+
+def _traverse_value(
+    value: object,
+    func: Callable[[CodeGenAstType], CodeGenAstType],
+    visited: set[int],
+) -> None:
+    """Recurse into a single attribute value, handling containers."""
+    if isinstance(value, (CodeGenAst, CodeGenAstList)):
+        rewriting_traverse(value, func, visited)
+    elif isinstance(value, (list, tuple)):
+        for item in value:  # type: ignore[reportUnknownVariableType]
+            _traverse_value(item, func, visited)  # type: ignore[reportUnknownVariableType]
+    elif isinstance(value, dict):
+        for v in value.values():  # type: ignore[reportUnknownVariableType]
+            _traverse_value(v, func, visited)  # type: ignore[reportUnknownVariableType]
 
 
 def morph_into(item: object, new_item: object) -> None:

fluent_codegen-0.3.0/src/fluent_codegen/remove_unused_assignments.py

@@ -0,0 +1,111 @@
+"""
+Utility to remove unused assignments from a Function body.
+
+Uses ``rewriting_traverse`` to walk the codegen AST.  Only handles a single
+function scope — raises ``AssertionError`` if a nested ``Scope`` (e.g. inner
+function or class) is encountered.
+"""
+
+from __future__ import annotations
+
+from .codegen import (
+    Assignment,
+    Block,
+    CodeGenAst,
+    CodeGenAstList,
+    CodeGenAstType,
+    Function,
+    Name,
+    Scope,
+    rewriting_traverse,
+)
+
+
+def _collect_blocks(func: Function) -> list[Block]:
+    """Return every Block reachable from *func*.body, checking for nested scopes."""
+    blocks: list[Block] = []
+    seen: set[int] = set()
+
+    def _walk(obj: object) -> None:
+        obj_id = id(obj)
+        if obj_id in seen:
+            return
+        seen.add(obj_id)
+
+        if isinstance(obj, Scope) and obj is not func:
+            if type(obj) is not Scope:
+                raise AssertionError(f"remove_unused_assignments does not handle nested Scopes ({type(obj).__name__})")
+            return
+
+        if isinstance(obj, Block):
+            blocks.append(obj)
+
+        # Recurse into attributes, finding Block children generically.
+        if isinstance(obj, (CodeGenAst, CodeGenAstList)):
+            for value in obj.__dict__.values():
+                _walk_value(value)
+
+    def _walk_value(value: object) -> None:
+        if isinstance(value, (CodeGenAst, CodeGenAstList, Scope)):
+            _walk(value)
+        elif isinstance(value, (list, tuple)):
+            for item in value:  # type: ignore[reportUnknownVariableType]
+                _walk_value(item)  # type: ignore[reportUnknownVariableType]
+
+    # Start from statements inside the body (not the Function itself, which is
+    # a Scope we need to skip).
+    for stmt in func.body.statements:
+        _walk_value(stmt)
+    # Also include the body block itself.
+    blocks.insert(0, func.body)
+    return blocks
+
+
+def _collect_name_references(func: Function) -> set[str]:
+    """Return the set of all name strings referenced as ``Name`` expressions."""
+    names: set[str] = set()
+
+    def _visitor(node: CodeGenAstType) -> CodeGenAstType:
+        if isinstance(node, Name):
+            names.add(node.name)
+        return node
+
+    rewriting_traverse(func.body, _visitor)
+    return names
+
+
+def _assigned_names(blocks: list[Block]) -> set[str]:
+    """Return all names that appear on the LHS of an ``_Assignment``."""
+    result: set[str] = set()
+    for block in blocks:
+        for stmt in block.statements:
+            if isinstance(stmt, Assignment):
+                result.add(stmt.name)
+    return result
+
+
+def _remove_once(func: Function, blocks: list[Block]) -> bool:
+    """Remove unused assignment statements.  Returns True if anything changed."""
+    referenced = _collect_name_references(func)
+    assigned = _assigned_names(blocks)
+    unused = assigned - referenced
+    if not unused:
+        return False
+
+    for block in blocks:
+        block.statements = [
+            stmt for stmt in block.statements if not (isinstance(stmt, Assignment) and stmt.name in unused)
+        ]
+    return True
+
+
+def remove_unused_assignments(func: Function) -> None:
+    """
+    Remove statements that assign to a name which is never read.
+
+    Works recursively: if removing ``x = y`` makes ``y`` unused, it will be
+    removed too.  Raises ``AssertionError`` on nested scopes.
+    """
+    blocks = _collect_blocks(func)
+    while _remove_once(func, blocks):
+        pass

{fluent_codegen-0.2 → fluent_codegen-0.3.0/src/fluent_codegen.egg-info}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: fluent-codegen
-Version: 0.2
+Version: 0.3.0
 Summary: A Python library for generating Python code via AST construction.
 Author-email: Luke Plant <luke@lukeplant.me.uk>
 License-Expression: Apache-2.0
 Project-URL: Repository, https://github.com/spookylukey/fluent-codegen
 Keywords: codegen,code-generation,ast,python,metaprogramming
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3 :: Only

{fluent_codegen-0.2 → fluent_codegen-0.3.0}/src/fluent_codegen.egg-info/SOURCES.txt

@@ -5,10 +5,12 @@ src/fluent_codegen/__init__.py
 src/fluent_codegen/ast_compat.py
 src/fluent_codegen/codegen.py
 src/fluent_codegen/py.typed
+src/fluent_codegen/remove_unused_assignments.py
 src/fluent_codegen/utils.py
 src/fluent_codegen.egg-info/PKG-INFO
 src/fluent_codegen.egg-info/SOURCES.txt
 src/fluent_codegen.egg-info/dependency_links.txt
 src/fluent_codegen.egg-info/top_level.txt
 tests/test_codegen.py
-tests/test_fizzbuzz_example.py
+tests/test_fizzbuzz_example.py
+tests/test_remove_unused.py

{fluent_codegen-0.2 → fluent_codegen-0.3.0}/tests/test_codegen.py

@@ -268,6 +268,65 @@ def test_function_add_args_reserves_name():
     assert_code_equal(ref, "my_arg")
 
 
+def test_function_args_property_empty():
+    module = codegen.Module()
+    func_name = module.scope.reserve_name("myfunc")
+    func = codegen.Function(func_name, parent_scope=module.scope)
+    assert func.args == ()
+
+
+def test_function_args_property():
+    module = codegen.Module()
+    func_name = module.scope.reserve_name("myfunc")
+    func = codegen.Function(func_name, args=["a", "b"], parent_scope=module.scope)
+    assert len(func.args) == 2
+    assert func.args[0].name == "a"
+    assert func.args[1].name == "b"
+
+
+def test_function_args_property_with_function_arg():
+    module = codegen.Module()
+    func_name = module.scope.reserve_name("myfunc")
+    func = codegen.Function(
+        func_name,
+        args=[
+            codegen.FunctionArg.positional("x"),
+            "y",
+            codegen.FunctionArg.keyword("z", default=codegen.Number(1)),
+        ],
+        parent_scope=module.scope,
+    )
+    assert len(func.args) == 3
+    assert func.args[0].name == "x"
+    assert func.args[0].kind == codegen.ArgKind.POSITIONAL_ONLY
+    assert func.args[1].name == "y"
+    assert func.args[1].kind == codegen.ArgKind.POSITIONAL_OR_KEYWORD
+    assert func.args[2].name == "z"
+    assert func.args[2].kind == codegen.ArgKind.KEYWORD_ONLY
+
+
+def test_function_args_property_after_add_args():
+    module = codegen.Module()
+    func_name = module.scope.reserve_name("myfunc")
+    func = codegen.Function(func_name, args=["a"], parent_scope=module.scope)
+    assert len(func.args) == 1
+    func.add_args(["b", "c"])
+    assert len(func.args) == 3
+    assert func.args[2].name == "c"
+
+
+def test_function_args_property_is_readonly():
+    """Mutating the returned tuple should not affect the function's internal args."""
+    module = codegen.Module()
+    func_name = module.scope.reserve_name("myfunc")
+    func = codegen.Function(func_name, args=["a", "b"], parent_scope=module.scope)
+    args = func.args
+    assert len(args) == 2
+    # tuple is immutable, so this should be a fresh copy each time
+    assert func.args is not func.args or isinstance(func.args, tuple)
+    assert len(func.args) == 2
+
+
 def test_function_args_name_reserved_check():
     module = codegen.Module()
     module.scope.reserve_function_arg_name("my_arg")
@@ -364,7 +423,7 @@ def test_create_assignment_bad():
     name = module.scope.reserve_name("x")
     module.create_assignment(name, codegen.String("a string"))
     stmt = module.statements[0]
-    assert isinstance(stmt, codegen._Assignment)
+    assert isinstance(stmt, codegen.Assignment)
     stmt.name = "something with a space"
     with pytest.raises(AssertionError):
         as_source_code(module)
@@ -437,19 +496,19 @@ def test_create_annotation_duplicate_name_gets_renamed():
 def test_create_annotation_bad_name():
     module = codegen.Module()
     # Force a bad name through by directly constructing _Annotation
-    from fluent_codegen.codegen import _Annotation
+    from fluent_codegen.codegen import Annotation
 
-    stmt = _Annotation("bad name", module.scope.name("int"))
+    stmt = Annotation("bad name", module.scope.name("int"))
     with pytest.raises(AssertionError):
         as_source_code(stmt)
 
 
 def test_annotation_has_assignment_for_name():
-    from fluent_codegen.codegen import _Annotation
+    from fluent_codegen.codegen import Annotation
 
     scope = codegen.Scope()
     scope.reserve_name("int")
-    stmt = _Annotation("x", scope.name("int"))
+    stmt = Annotation("x", scope.name("int"))
     assert stmt.has_assignment_for_name("x") is True
     assert stmt.has_assignment_for_name("y") is False
 
@@ -1349,6 +1408,440 @@ def test_rewriting_traverse_tuple():
     codegen.rewriting_traverse(t, lambda n: n)
 
 
+def _collect_traversed_types(root):
+    """Helper: traverse a tree and return list of (class_name) for every node visited."""
+    visited = []
+
+    def visitor(node):
+        visited.append(type(node).__name__)
+        return node
+
+    codegen.rewriting_traverse(root, visitor)
+    return visited
+
+
+def test_rewriting_traverse_complex_module():
+    """Test traversal visits all nodes in a complex module with nested structures."""
+    module = codegen.Module()
+    scope = module.scope
+
+    # Function with decorators, return type, body containing if/else, assignments, returns
+    scope.reserve_name("my_decorator")
+    decorator = codegen.Name("my_decorator", scope)
+    func, _ = module.create_function(
+        "process",
+        args=["items", "flag"],
+        decorators=[decorator],
+        return_type=codegen.Name("str", scope),
+    )
+    n_items = codegen.Name("items", func)
+    n_flag = codegen.Name("flag", func)
+
+    # Assignment with type hint
+    result_name = func.body.scope.reserve_name("result")
+    func.body.create_assignment(result_name, codegen.String(""), type_hint=codegen.Name("str", func))
+
+    # If/elif/else
+    if_stmt = func.body.create_if()
+    branch1 = if_stmt.create_if_branch(n_flag.eq(codegen.Bool(True)))
+    branch1.create_assignment(
+        result_name,
+        codegen.function_call("str", [n_items], {}, func),
+        allow_multiple=True,
+    )
+    branch2 = if_stmt.create_if_branch(n_flag.eq(codegen.Bool(False)))
+    branch2.create_return(codegen.String("none"))
+    if_stmt.else_block.create_return(codegen.String("default"))
+
+    # Return
+    func.body.create_return(codegen.Name("result", func))
+
+    visited = _collect_traversed_types(module)
+
+    # Verify key node types are all visited
+    assert "Module" in visited
+    assert "Function" in visited
+    assert "Block" in visited
+    assert "If" in visited
+    assert "Equals" in visited
+    assert "String" in visited
+    assert "Bool" in visited
+    assert "Return" in visited
+    assert "Call" in visited
+    assert "Name" in visited
+
+
+def test_rewriting_traverse_call_with_kwargs():
+    """Test that kwargs dict values in Call nodes are traversed."""
+    scope = codegen.Scope()
+    func_name = scope.create_name("my_func")
+    call = codegen.Call(
+        func_name,
+        [codegen.String("positional")],
+        {"key1": codegen.String("val1"), "key2": codegen.Number(42)},
+    )
+
+    visited = _collect_traversed_types(call)
+    assert "Call" in visited
+    assert "Name" in visited
+    # The positional arg
+    assert visited.count("String") >= 2  # "positional" and "val1"
+    assert "Number" in visited  # 42 from kwargs
+
+
+def test_rewriting_traverse_replaces_in_kwargs():
+    """Test that rewriting_traverse can replace nodes inside Call kwargs."""
+    scope = codegen.Scope()
+    func_name = scope.create_name("f")
+    call = codegen.Call(
+        func_name,
+        [],
+        {"k": codegen.String("old")},
+    )
+
+    def replace_old(node):
+        if isinstance(node, codegen.String) and node.string_value == "old":
+            return codegen.String("new")
+        return node
+
+    codegen.rewriting_traverse(call, replace_old)
+    assert_code_equal(call, "f(k='new')")
+
+
+def test_rewriting_traverse_function_decorators_and_return_type():
+    """Test that decorators and return_type on Function are traversed."""
+    scope = codegen.Scope()
+    decorator = codegen.String("deco_marker")
+    ret_type = codegen.String("ret_marker")
+    func = codegen.Function("myfunc", parent_scope=scope, decorators=[decorator], return_type=ret_type)
+
+    visited = _collect_traversed_types(func)
+    assert visited.count("String") == 2  # decorator + return_type
+
+
+def test_rewriting_traverse_replaces_in_decorator():
+    """Test replacing a decorator expression via traverse."""
+    scope = codegen.Scope()
+    scope.reserve_name("old_deco")
+    scope.reserve_name("new_deco")
+    func = codegen.Function(
+        "myfunc",
+        parent_scope=scope,
+        decorators=[codegen.Name("old_deco", scope)],
+    )
+
+    def replace_deco(node):
+        if isinstance(node, codegen.Name) and node.name == "old_deco":
+            return codegen.Name("new_deco", scope)
+        return node
+
+    codegen.rewriting_traverse(func, replace_deco)
+    decorator = func.decorators[0]
+    assert isinstance(decorator, codegen.Name)
+    assert decorator.name == "new_deco"
+
+
+def test_rewriting_traverse_assignment_type_hint():
+    """Test that type_hint on _Assignment is traversed."""
+    module = codegen.Module()
+    name = module.scope.reserve_name("x")
+    module.create_assignment(name, codegen.String("hello"), type_hint=codegen.Name("str", module.scope))
+
+    visited = _collect_traversed_types(module)
+    # The type hint Name("str") should be visited
+    assert visited.count("Name") >= 1
+
+
+def test_rewriting_traverse_annotation():
+    """Test that annotation Expression on _Annotation is traversed."""
+    module = codegen.Module()
+    name = module.scope.reserve_name("x")
+    module.create_annotation(name, codegen.Name("int", module.scope))
+
+    visited = _collect_traversed_types(module)
+    # Module -> Block(statements) -> _Annotation -> annotation(Name)
+    assert "Name" in visited
+
+
+def test_rewriting_traverse_with_statement():
+    """Test traversal into With statement's context_expr, target, and body."""
+    module = codegen.Module()
+    module.scope.reserve_name("ctx_manager")
+    module.scope.reserve_name("f")
+    ctx = codegen.function_call("ctx_manager", [codegen.String("file.txt")], {}, module.scope)
+    with_stmt = module.create_with(ctx, target=codegen.Name("f", module.scope))
+    with_stmt.body.create_return(codegen.String("done"))
+
+    visited = _collect_traversed_types(module)
+    assert "With" in visited
+    assert "Call" in visited
+    assert "Return" in visited
+
+
+def test_rewriting_traverse_try_except():
+    """Test traversal into Try blocks."""
+    module = codegen.Module()
+    exc = codegen.Name("ValueError", module.scope)
+    try_stmt = codegen.Try([exc], module.scope)
+    try_stmt.try_block.create_return(codegen.String("tried"))
+    try_stmt.except_block.create_return(codegen.String("caught"))
+    try_stmt.else_block.create_return(codegen.String("else"))
+    module.add_statement(try_stmt)
+
+    visited = _collect_traversed_types(module)
+    assert "Try" in visited
+    assert visited.count("Block") >= 3  # try, except, else blocks
+    assert visited.count("Return") >= 3
+    assert visited.count("String") >= 3
+
+
+def test_rewriting_traverse_dict_expression():
+    """Test traversal into Dict pairs (tuples of expressions)."""
+    d = codegen.Dict(
+        [
+            (codegen.String("k1"), codegen.Number(1)),
+            (codegen.String("k2"), codegen.Number(2)),
+        ]
+    )
+
+    visited = _collect_traversed_types(d)
+    assert visited.count("String") == 2
+    assert visited.count("Number") == 2
+
+
+def test_rewriting_traverse_nested_binary_ops():
+    """Test deep nesting of binary operators."""
+    # (1 + 2) * (3 - 4)
+    expr = codegen.Number(1).add(codegen.Number(2)).mul(codegen.Number(3).sub(codegen.Number(4)))
+
+    visited = _collect_traversed_types(expr)
+    assert visited.count("Number") == 4
+    assert "Mul" in visited
+    assert "Add" in visited
+    assert "Sub" in visited
+
+
+def test_rewriting_traverse_subscript():
+    """Test traversal into Subscript value and slice."""
+    scope = codegen.Scope()
+    scope.reserve_name("items")
+    expr = codegen.Name("items", scope).subscript(codegen.Number(0))
+
+    visited = _collect_traversed_types(expr)
+    assert "Subscript" in visited
+    assert "Name" in visited
+    assert "Number" in visited
+
+
+def test_rewriting_traverse_attr():
+    """Test traversal into Attr value."""
+    scope = codegen.Scope()
+    scope.reserve_name("obj")
+    expr = codegen.Name("obj", scope).attr("prop")
+
+    visited = _collect_traversed_types(expr)
+    assert "Attr" in visited
+    assert "Name" in visited
+
+
+def test_rewriting_traverse_starred():
+    """Test traversal into Starred value."""
+    scope = codegen.Scope()
+    scope.reserve_name("args")
+    expr = codegen.Name("args", scope).starred()
+
+    visited = _collect_traversed_types(expr)
+    assert "Starred" in visited
+    assert "Name" in visited
+
+
+def test_rewriting_traverse_list_tuple_set():
+    """Test traversal into List, Tuple, Set items."""
+    for cls in [codegen.List, codegen.Tuple, codegen.Set]:
+        coll = cls([codegen.String("a"), codegen.Number(1)])
+        visited = _collect_traversed_types(coll)
+        assert "String" in visited
+        assert "Number" in visited
+
+
+def test_rewriting_traverse_class_with_bases_and_decorators():
+    """Test traversal into Class body, bases, and decorators."""
+    module = codegen.Module()
+    module.scope.reserve_name("BaseClass")
+    module.scope.reserve_name("my_class_deco")
+    base = codegen.Name("BaseClass", module.scope)
+    deco = codegen.Name("my_class_deco", module.scope)
+    cls, _ = module.create_class("MyClass", bases=[base], decorators=[deco])
+
+    visited = _collect_traversed_types(module)
+    assert "Class" in visited
+    assert "Block" in visited
+    # bases and decorators should be visited
+    assert visited.count("Name") >= 2
+
+
+def test_rewriting_traverse_assert():
+    """Test traversal into Assert test and msg."""
+    module = codegen.Module()
+    module.create_assert(codegen.Bool(True), codegen.String("oops"))
+
+    visited = _collect_traversed_types(module)
+    assert "Assert" in visited
+    assert "Bool" in visited
+    assert "String" in visited
+
+
+def test_rewriting_traverse_fstring():
+    """Test traversal into FStringJoin parts."""
+    scope = codegen.Scope()
+    scope.reserve_name("world")
+    fstr = codegen.FStringJoin([codegen.String("hello "), codegen.Name("world", scope)])
+
+    visited = _collect_traversed_types(fstr)
+    assert "FStringJoin" in visited
+    assert "String" in visited
+    assert "Name" in visited
+
+
+def test_rewriting_traverse_deeply_nested_codegen_tree():
+    """
+    Build a complex, deeply-nested codegen tree and verify that rewriting_traverse
+    visits every single CodeGenAst/CodeGenAstList node by replacing all String
+    values with 'REPLACED'.
+    """
+    module = codegen.Module()
+    scope = module.scope
+
+    # Import
+    module.create_import("os")
+    module.create_import_from(from_="sys", import_="argv")
+
+    # Class with decorator and base
+    scope.reserve_name("dataclass")
+    class_deco = codegen.Name("dataclass", scope)
+    base = codegen.Name("object", scope)
+    cls, _ = module.create_class("Config", bases=[base], decorators=[class_deco])
+    field_name = cls.body.scope.reserve_name("name")
+    cls.body.create_assignment(field_name, codegen.String("default_name"))
+
+    # Function with kwargs call, nested if, try/except, with, assert
+    scope.reserve_name("process")
+    func, _ = module.create_function(
+        "run",
+        args=["config"],
+        return_type=codegen.Name("bool", scope),
+    )
+    config = codegen.Name("config", func)
+
+    # Assignment with function call using kwargs
+    result_name = func.body.scope.reserve_name("result")
+    func.body.create_assignment(
+        result_name,
+        codegen.function_call(
+            "process",
+            [config.attr("name")],
+            {"timeout": codegen.Number(30)},
+            func,
+        ),
+    )
+
+    # Nested if
+    if_stmt = func.body.create_if()
+    branch = if_stmt.create_if_branch(codegen.Name("result", func).eq(codegen.String("ok")))
+    branch.create_return(codegen.Bool(True))
+
+    # Try/except in else
+    try_stmt = codegen.Try([codegen.Name("Exception", func)], func)
+    try_stmt.try_block.create_return(codegen.Bool(False))
+    try_stmt.except_block.create_return(codegen.Bool(False))
+    if_stmt.else_block.add_statement(try_stmt)
+
+    # With statement
+    func.reserve_name("open_log")
+    ctx_expr = codegen.function_call("open_log", [codegen.String("log.txt")], {}, func)
+    with_block = func.body.create_with(ctx_expr)
+    with_block.body.create_return(codegen.String("logged"))
+
+    # Assert
+    func.body.create_assert(
+        codegen.Name("result", func).ne(codegen.NoneExpr()),
+        codegen.String("must not be None"),
+    )
+
+    # Now do a rewriting_traverse that replaces all Strings
+    string_count = [0]
+
+    def count_and_replace_strings(node):
+        if isinstance(node, codegen.String):
+            string_count[0] += 1
+            return codegen.String("REPLACED")
+        return node
+
+    codegen.rewriting_traverse(module, count_and_replace_strings)
+
+    # We should have found all string literals in the tree
+    assert string_count[0] >= 5  # default_name, ok, log.txt, logged, must not be None
+
+    # Verify ALL strings are now REPLACED in the generated source
+    source = module.as_python_source()
+    for original in ["default_name", "'ok'", "log.txt", "logged", "must not be None"]:
+        assert original not in source, f"String '{original}' should have been replaced but found in: {source}"
+    assert "REPLACED" in source
+
+
+def test_rewriting_traverse_replace_number_in_nested_kwargs():
+    """
+    Specifically test that numbers deep inside kwargs of a Call inside a
+    function body can be found and replaced.
+    """
+    module = codegen.Module()
+    module.scope.reserve_name("setup")
+    func, _ = module.create_function("f", args=[])
+    func.body.create_assignment(
+        func.body.scope.reserve_name("x"),
+        codegen.function_call(
+            "setup",
+            [],
+            {"timeout": codegen.Number(99), "retries": codegen.Number(3)},
+            func,
+        ),
+    )
+
+    def double_numbers(node):
+        if isinstance(node, codegen.Number):
+            return codegen.Number(node.number * 2)
+        return node
+
+    codegen.rewriting_traverse(module, double_numbers)
+    source = module.as_python_source()
+    assert "198" in source  # 99 * 2
+    assert "6" in source  # 3 * 2
+    assert "99" not in source
+
+
+def test_rewriting_traverse_none_expr():
+    """Test that NoneExpr nodes are visited (they previously lacked child_elements)."""
+    scope = codegen.Scope()
+    scope.reserve_name("x")
+    expr = codegen.Name("x", scope).eq(codegen.NoneExpr())
+
+    visited = _collect_traversed_types(expr)
+    assert "NoneExpr" in visited
+    assert "Equals" in visited
+    assert "Name" in visited
+
+
+def test_rewriting_traverse_import_nodes():
+    """Test that Import and ImportFrom nodes are visited (they previously lacked child_elements)."""
+    module = codegen.Module()
+    module.create_import("os")
+    module.create_import_from(from_="sys", import_="argv")
+
+    visited = _collect_traversed_types(module)
+    assert "Import" in visited
+    assert "ImportFrom" in visited
+
+
 # --- auto() tests ---
 
 

fluent_codegen-0.3.0/tests/test_remove_unused.py

@@ -0,0 +1,166 @@
+import pytest
+
+from fluent_codegen.codegen import (
+    Function,
+    Name,
+    Number,
+    Scope,
+    String,
+    constants,
+)
+from fluent_codegen.remove_unused_assignments import remove_unused_assignments
+
+
+def make_func(parent_scope=None):
+    """Helper: create a Function named 'f' with no args."""
+    if parent_scope is None:
+        parent_scope = Scope()
+        parent_scope.reserve_name("f")
+    func = Function("f", args=[], parent_scope=parent_scope)
+    return func
+
+
+def source(func):
+    return func.as_python_source().strip()
+
+
+# ── positive cases (something gets removed) ──────────────────────────
+
+
+def test_remove_simple_unused():
+    func = make_func()
+    x = func.body.scope.create_name("x")
+    func.body.create_assignment(x, Number(1))
+    func.body.create_return(String("done"))
+
+    remove_unused_assignments(func)
+
+    assert source(func) == "def f():\n    return 'done'"
+
+
+def test_cascading_removal():
+    """x = y, y = 1; x unused ⇒ remove x = y ⇒ y now unused ⇒ remove y = 1."""
+    func = make_func()
+    y = func.body.scope.create_name("y")
+    func.body.create_assignment(y, Number(1))
+    x = func.body.scope.create_name("x")
+    func.body.create_assignment(x, Name("y", func.body.scope))
+    func.body.create_return(String("done"))
+
+    remove_unused_assignments(func)
+
+    assert source(func) == "def f():\n    return 'done'"
+
+
+def test_remove_unused_in_if_block():
+    """Unused assignment inside an if-branch is removed."""
+    func = make_func()
+    x = func.body.scope.create_name("x")
+    if_stmt = func.body.create_if()
+    branch = if_stmt.create_if_branch(constants.True_)
+    branch.create_assignment(x, Number(42))
+    func.body.create_return(String("done"))
+
+    remove_unused_assignments(func)
+
+    # The assignment in the if-branch should be gone; branch body is now empty
+    src = source(func)
+    assert "x = 42" not in src
+
+
+def test_remove_unused_in_try_block():
+    """Unused assignment inside a try block is removed."""
+    from fluent_codegen.codegen import Try
+
+    func = make_func()
+    x = func.body.scope.create_name("x")
+    scope = func.body.scope
+    scope.reserve_name("Exception", is_builtin=True)
+    try_stmt = Try(
+        catch_exceptions=[Name("Exception", scope)],
+        parent_scope=scope,
+    )
+    try_stmt.try_block.create_assignment(x, Number(1))
+    func.body.add_statement(try_stmt)
+    func.body.create_return(String("ok"))
+
+    remove_unused_assignments(func)
+
+    src = source(func)
+    assert "x = 1" not in src
+
+
+# ── negative cases (nothing should be removed) ───────────────────────
+
+
+def test_keep_used_assignment():
+    func = make_func()
+    x = func.body.scope.create_name("x")
+    func.body.create_assignment(x, Number(1))
+    func.body.create_return(Name("x", func.body.scope))
+
+    remove_unused_assignments(func)
+
+    assert source(func) == "def f():\n    x = 1\n    return x"
+
+
+def test_keep_used_in_nested_block():
+    """x assigned at top level, used inside an if-branch — keep it."""
+    func = make_func()
+    x = func.body.scope.create_name("x")
+    func.body.create_assignment(x, Number(1))
+    if_stmt = func.body.create_if()
+    branch = if_stmt.create_if_branch(constants.True_)
+    branch.create_return(Name("x", func.body.scope))
+
+    remove_unused_assignments(func)
+
+    src = source(func)
+    assert "x = 1" in src
+
+
+def test_keep_function_args():
+    """Function arguments should never be removed even if unused in body."""
+    scope = Scope()
+    scope.reserve_name("g")
+    func = Function("g", args=["a"], parent_scope=scope)
+    func.body.create_return(String("hi"))
+
+    remove_unused_assignments(func)
+
+    assert source(func) == "def g(a):\n    return 'hi'"
+
+
+def test_keep_when_used_in_another_assignment_value():
+    """y = 1; x = y; return x  ⇒  y is used (in x's value), so keep both."""
+    func = make_func()
+    y = func.body.scope.create_name("y")
+    func.body.create_assignment(y, Number(1))
+    x = func.body.scope.create_name("x")
+    func.body.create_assignment(x, Name("y", func.body.scope))
+    func.body.create_return(Name("x", func.body.scope))
+
+    remove_unused_assignments(func)
+
+    src = source(func)
+    assert "y = 1" in src
+    assert "x = y" in src
+
+
+# ── error case: nested scope ─────────────────────────────────────────
+
+
+def test_raises_on_nested_function():
+    func = make_func()
+    func.body.create_function("inner", args=[])
+
+    with pytest.raises(AssertionError, match="nested.*[Ss]cope"):
+        remove_unused_assignments(func)
+
+
+def test_raises_on_nested_class():
+    func = make_func()
+    func.body.create_class("MyClass")
+
+    with pytest.raises(AssertionError, match="nested.*[Ss]cope"):
+        remove_unused_assignments(func)