trolskgen 0.0.1__tar.gz

trolskgen-0.0.1/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Oliver Russell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

trolskgen-0.0.1/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: trolskgen
+Version: 0.0.1
+Summary: Cute Python codegen
+Author-email: Oliver Russell <ojhrussell@gmail.com>
+Maintainer-email: Oliver Russell <ojhrussell@gmail.com>
+Project-URL: homepage, https://github.com/leontrolski/trolskgen
+Keywords: codegen
+Classifier: Programming Language :: Python
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Provides-Extra: dev
+Requires-Dist: pytest==8.3.5; extra == "dev"
+Requires-Dist: ruff==0.11.2; extra == "dev"
+Requires-Dist: mypy==1.15.0; extra == "dev"
+Requires-Dist: rich==14.0.0; extra == "dev"
+Requires-Dist: pydantic==2.11.7; extra == "dev"
+Dynamic: license-file
+
+# Trolskgen
+
+# Hello World
+
+After `pip install trolskgen`, just run:
+
+# TODO
+
+- README
+    - Walk through each converter
+    - Plugins example
+- Implement comments somehow? Monkeypatch ast?
+- Notes on comments - use docstrings etc.
+
+# Development
+
+```
+uv pip install -e '.[dev]'
+mypy .
+pytest -vv
+```

trolskgen-0.0.1/README.md

@@ -0,0 +1,21 @@
+# Trolskgen
+
+# Hello World
+
+After `pip install trolskgen`, just run:
+
+# TODO
+
+- README
+    - Walk through each converter
+    - Plugins example
+- Implement comments somehow? Monkeypatch ast?
+- Notes on comments - use docstrings etc.
+
+# Development
+
+```
+uv pip install -e '.[dev]'
+mypy .
+pytest -vv
+```

trolskgen-0.0.1/pyproject.toml

@@ -0,0 +1,37 @@
+[project]
+name = "trolskgen"
+version = "0.0.1"
+description = "Cute Python codegen"
+readme = "README.md"
+requires-python = ">=3.12"
+license = {file = "LICENSE"}
+keywords = ["codegen"]
+authors = [
+  {name = "Oliver Russell", email = "ojhrussell@gmail.com"},
+]
+maintainers = [
+  {name = "Oliver Russell", email = "ojhrussell@gmail.com"},
+]
+classifiers = [
+  "Programming Language :: Python",
+]
+
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+  "pytest==8.3.5",
+  "ruff==0.11.2",
+  "mypy==1.15.0",
+  "rich==14.0.0",
+  "pydantic==2.11.7",
+]
+
+[project.urls]
+homepage = "https://github.com/leontrolski/trolskgen"
+
+[tool.ruff]
+line-length = 120
+
+[tool.mypy]
+strict = true

trolskgen-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

trolskgen-0.0.1/src/trolskgen/__init__.py

@@ -0,0 +1,6 @@
+from trolskgen.core import Config as Config
+from trolskgen.core import F as F
+from trolskgen.core import TrolskgenError as TrolskgenError
+from trolskgen.core import to_ast as to_ast
+from trolskgen.core import to_source as to_source
+from trolskgen.templates import t as t

trolskgen-0.0.1/src/trolskgen/ast_types.py

@@ -0,0 +1,205 @@
+import ast
+import sys
+from types import NoneType
+from typing import Any
+
+FIELD_MAPS: dict[type[Any], dict[str, Any]] = {
+    NoneType: {},
+    str: {},
+    int: {},
+    object: {},
+    ast.AST: {},
+    ast.mod: {},
+    ast.Module: {"body": list[ast.stmt], "type_ignores": list[ast.type_ignore]},
+    ast.Interactive: {"body": list[ast.stmt]},
+    ast.Expression: {"body": ast.expr},
+    ast.FunctionType: {"argtypes": list[ast.expr], "returns": ast.expr},
+    ast.stmt: {},
+    ast.FunctionDef: {
+        "name": str,
+        "args": ast.arguments,
+        "body": list[ast.stmt],
+        "decorator_list": list[ast.expr],
+        "returns": ast.expr | NoneType,
+        "type_comment": str | NoneType,
+        "type_params": list[ast.type_param],
+    },
+    ast.AsyncFunctionDef: {
+        "name": str,
+        "args": ast.arguments,
+        "body": list[ast.stmt],
+        "decorator_list": list[ast.expr],
+        "returns": ast.expr | NoneType,
+        "type_comment": str | NoneType,
+        "type_params": list[ast.type_param],
+    },
+    ast.ClassDef: {
+        "name": str,
+        "bases": list[ast.expr],
+        "keywords": list[ast.keyword],
+        "body": list[ast.stmt],
+        "decorator_list": list[ast.expr],
+        "type_params": list[ast.type_param],
+    },
+    ast.Return: {"value": ast.expr | NoneType},
+    ast.Delete: {"targets": list[ast.expr]},
+    ast.Assign: {"targets": list[ast.expr], "value": ast.expr, "type_comment": str | NoneType},
+    ast.TypeAlias: {"name": ast.expr, "type_params": list[ast.type_param], "value": ast.expr},
+    ast.AugAssign: {"target": ast.expr, "op": ast.operator, "value": ast.expr},
+    ast.AnnAssign: {"target": ast.expr, "annotation": ast.expr, "value": ast.expr | NoneType, "simple": int},
+    ast.For: {
+        "target": ast.expr,
+        "iter": ast.expr,
+        "body": list[ast.stmt],
+        "orelse": list[ast.stmt],
+        "type_comment": str | NoneType,
+    },
+    ast.AsyncFor: {
+        "target": ast.expr,
+        "iter": ast.expr,
+        "body": list[ast.stmt],
+        "orelse": list[ast.stmt],
+        "type_comment": str | NoneType,
+    },
+    ast.While: {"test": ast.expr, "body": list[ast.stmt], "orelse": list[ast.stmt]},
+    ast.If: {"test": ast.expr, "body": list[ast.stmt], "orelse": list[ast.stmt]},
+    ast.With: {"items": list[ast.withitem], "body": list[ast.stmt], "type_comment": str | NoneType},
+    ast.AsyncWith: {"items": list[ast.withitem], "body": list[ast.stmt], "type_comment": str | NoneType},
+    ast.Match: {"subject": ast.expr, "cases": list[ast.match_case]},
+    ast.Raise: {"exc": ast.expr | NoneType, "cause": ast.expr | NoneType},
+    ast.Try: {
+        "body": list[ast.stmt],
+        "handlers": list[ast.excepthandler],
+        "orelse": list[ast.stmt],
+        "finalbody": list[ast.stmt],
+    },
+    ast.TryStar: {
+        "body": list[ast.stmt],
+        "handlers": list[ast.excepthandler],
+        "orelse": list[ast.stmt],
+        "finalbody": list[ast.stmt],
+    },
+    ast.Assert: {"test": ast.expr, "msg": ast.expr | NoneType},
+    ast.Import: {"names": list[ast.alias]},
+    ast.ImportFrom: {"module": str | NoneType, "names": list[ast.alias], "level": int | NoneType},
+    ast.Global: {"names": list[str]},
+    ast.Nonlocal: {"names": list[str]},
+    ast.Expr: {"value": ast.expr},
+    ast.Pass: {},
+    ast.Break: {},
+    ast.Continue: {},
+    ast.expr: {},
+    ast.BoolOp: {"op": ast.boolop, "values": list[ast.expr]},
+    ast.NamedExpr: {"target": ast.expr, "value": ast.expr},
+    ast.BinOp: {"left": ast.expr, "op": ast.operator, "right": ast.expr},
+    ast.UnaryOp: {"op": ast.unaryop, "operand": ast.expr},
+    ast.Lambda: {"args": ast.arguments, "body": ast.expr},
+    ast.IfExp: {"test": ast.expr, "body": ast.expr, "orelse": ast.expr},
+    ast.Dict: {"keys": list[ast.expr], "values": list[ast.expr]},
+    ast.Set: {"elts": list[ast.expr]},
+    ast.ListComp: {"elt": ast.expr, "generators": list[ast.comprehension]},
+    ast.SetComp: {"elt": ast.expr, "generators": list[ast.comprehension]},
+    ast.DictComp: {"key": ast.expr, "value": ast.expr, "generators": list[ast.comprehension]},
+    ast.GeneratorExp: {"elt": ast.expr, "generators": list[ast.comprehension]},
+    ast.Await: {"value": ast.expr},
+    ast.Yield: {"value": ast.expr | NoneType},
+    ast.YieldFrom: {"value": ast.expr},
+    ast.Compare: {"left": ast.expr, "ops": list[ast.cmpop], "comparators": list[ast.expr]},
+    ast.Call: {"func": ast.expr, "args": list[ast.expr], "keywords": list[ast.keyword]},
+    ast.FormattedValue: {"value": ast.expr, "conversion": int, "format_spec": ast.expr | NoneType},
+    ast.JoinedStr: {"values": list[ast.expr]},
+    ast.Constant: {"value": object, "kind": str | NoneType},
+    ast.Attribute: {"value": ast.expr, "attr": str},
+    ast.Subscript: {"value": ast.expr, "slice": ast.expr},
+    ast.Starred: {"value": ast.expr},
+    ast.Name: {"id": str},
+    ast.List: {"elts": list[ast.expr]},
+    ast.Tuple: {"elts": list[ast.expr]},
+    ast.Slice: {"lower": ast.expr | NoneType, "upper": ast.expr | NoneType, "step": ast.expr | NoneType},
+    ast.expr_context: {},
+    ast.Load: {},
+    ast.Store: {},
+    ast.Del: {},
+    ast.boolop: {},
+    ast.And: {},
+    ast.Or: {},
+    ast.operator: {},
+    ast.Add: {},
+    ast.Sub: {},
+    ast.Mult: {},
+    ast.MatMult: {},
+    ast.Div: {},
+    ast.Mod: {},
+    ast.Pow: {},
+    ast.LShift: {},
+    ast.RShift: {},
+    ast.BitOr: {},
+    ast.BitXor: {},
+    ast.BitAnd: {},
+    ast.FloorDiv: {},
+    ast.unaryop: {},
+    ast.Invert: {},
+    ast.Not: {},
+    ast.UAdd: {},
+    ast.USub: {},
+    ast.cmpop: {},
+    ast.Eq: {},
+    ast.NotEq: {},
+    ast.Lt: {},
+    ast.LtE: {},
+    ast.Gt: {},
+    ast.GtE: {},
+    ast.Is: {},
+    ast.IsNot: {},
+    ast.In: {},
+    ast.NotIn: {},
+    ast.comprehension: {"target": ast.expr, "iter": ast.expr, "ifs": list[ast.expr], "is_async": int},
+    ast.excepthandler: {},
+    ast.ExceptHandler: {"type": ast.expr | NoneType, "name": str | NoneType, "body": list[ast.stmt]},
+    ast.arguments: {
+        "posonlyargs": list[ast.arg],
+        "args": list[ast.arg],
+        "vararg": ast.arg | NoneType,
+        "kwonlyargs": list[ast.arg],
+        "kw_defaults": list[ast.expr],
+        "kwarg": ast.arg | NoneType,
+        "defaults": list[ast.expr],
+    },
+    ast.arg: {"arg": str, "annotation": ast.expr | NoneType, "type_comment": str | NoneType},
+    ast.keyword: {"arg": str | NoneType, "value": ast.expr},
+    ast.alias: {"name": str, "asname": str | NoneType},
+    ast.withitem: {"context_expr": ast.expr, "optional_vars": ast.expr | NoneType},
+    ast.match_case: {"pattern": ast.pattern, "guard": ast.expr | NoneType, "body": list[ast.stmt]},
+    ast.pattern: {},
+    ast.MatchValue: {"value": ast.expr},
+    ast.MatchSingleton: {"value": object},
+    ast.MatchSequence: {"patterns": list[ast.pattern]},
+    ast.MatchMapping: {"keys": list[ast.expr], "patterns": list[ast.pattern], "rest": str | NoneType},
+    ast.MatchClass: {
+        "cls": ast.expr,
+        "patterns": list[ast.pattern],
+        "kwd_attrs": list[str],
+        "kwd_patterns": list[ast.pattern],
+    },
+    ast.MatchStar: {"name": str | NoneType},
+    ast.MatchAs: {"pattern": ast.pattern | NoneType, "name": str | NoneType},
+    ast.MatchOr: {"patterns": list[ast.pattern]},
+    ast.type_ignore: {},
+    ast.TypeIgnore: {"lineno": int, "tag": str},
+    ast.type_param: {},
+    ast.TypeVar: {"name": str, "bound": ast.expr | NoneType, "default_value": ast.expr | NoneType},
+    ast.ParamSpec: {"name": str, "default_value": ast.expr | NoneType},
+    ast.TypeVarTuple: {"name": str, "default_value": ast.expr | NoneType},
+    ast.slice: {},
+    ast.Index: {},
+    ast.ExtSlice: {},
+    ast.Suite: {},
+    ast.AugLoad: {},
+    ast.AugStore: {},
+    ast.Param: {},
+}
+if sys.version_info >= (3, 14):
+    FIELD_MAPS |= {
+        ast.Interpolation: {"value": ast.expr, "str": object, "conversion": int, "format_spec": ast.expr | NoneType},
+        ast.TemplateStr: {"values": list[ast.expr]},
+    }

trolskgen-0.0.1/src/trolskgen/converters.py

@@ -0,0 +1,294 @@
+from __future__ import annotations
+
+import ast
+import datetime as dt
+import enum
+import inspect
+import textwrap
+import zoneinfo
+from dataclasses import MISSING, dataclass, fields, is_dataclass
+from types import NoneType, UnionType
+from typing import Annotated, Any, TypeVar, Union, cast, get_args, get_origin
+
+from typing_extensions import TypeIs
+
+from trolskgen import ast_types, core, templates
+
+ASTValue = ast.AST | list[ast.stmt] | str
+T = TypeVar("T", bound=ASTValue)
+
+
+def converter_ast(o: Any, f: core.F) -> ast.AST | None:
+    if not isinstance(o, ast.AST):
+        return None
+    return o
+
+
+@core.upcast_expr
+def converter_simple(o: Any, f: core.F) -> ast.AST | None:
+    if isinstance(o, int | float | str | bool | NoneType):
+        return ast.Constant(value=o)
+    if isinstance(o, list):
+        return ast.List(elts=[_downcast(ast.expr, f(e)) for e in o])
+    if isinstance(o, tuple):
+        return ast.Tuple(elts=[_downcast(ast.expr, f(e)) for e in o])
+    if isinstance(o, dict):
+        return ast.Dict(
+            keys=[_downcast(ast.expr, f(k)) for k in o.keys()],
+            values=[_downcast(ast.expr, f(v)) for v in o.values()],
+        )
+    if isinstance(o, set):
+        return ast.Set(elts=[_downcast(ast.expr, f(e)) for e in o])
+    return None
+
+
+DONT_PREFIX_WITH_MODULE = {"builtins", "typing"}
+
+
+@core.upcast_expr
+def converter_types_and_functions(o: Any, f: core.F) -> ast.AST | None:
+    if isinstance(o, type) or inspect.isfunction(o):
+        module_name = o.__module__ + "."
+        if o.__module__ in DONT_PREFIX_WITH_MODULE:
+            module_name = ""
+        return f(templates.t(module_name + o.__qualname__))
+    return None
+
+
+class FieldMissing: ...
+
+
+FIELD_MISSING = FieldMissing()
+
+
+@core.upcast_expr
+def converter_common(o: Any, f: core.F) -> ast.AST | None:
+    if o is dt.UTC:
+        return f(templates.t("dt.UTC"))
+    if isinstance(o, zoneinfo.ZoneInfo):
+        return f(templates.t("zoneinfo.ZoneInfo({key})", key=o.key))
+    if isinstance(o, dt.datetime):
+        parts: list[int | ast.AST] = [o.year, o.month, o.day]
+        if o.hour or o.minute or o.second or o.microsecond:
+            parts.append(o.hour)
+            parts.append(o.minute)
+            parts.append(o.second)
+        if o.microsecond:
+            parts.append(o.microsecond)
+        if o.tzinfo is not None:
+            parts.append(f(templates.t("tzinfo={tzinfo}", tzinfo=o.tzinfo)))
+        return f(templates.t("dt.datetime({parts:*})", parts=parts))
+    if isinstance(o, dt.date):
+        return f(templates.t("dt.date({year}, {month}, {day})", year=o.year, month=o.month, day=o.day))
+    if isinstance(o, enum.Enum):
+        return f(templates.t("{enum}.{name}", enum=type(o), name=templates.t(o.name)))
+    if is_dataclass(o):
+        args = list[ast.AST]()
+        for field in fields(o):
+            value = getattr(o, field.name, FIELD_MISSING)
+            if value == field.default:
+                continue
+            if field.default_factory != MISSING and value == field.default_factory():
+                continue
+            args.append(f(templates.t("{key}={value}", key=templates.t(field.name), value=value)))
+        return f(templates.t("{c}({args:*})", c=type(o), args=args))
+    return None
+
+
+@core.upcast_expr
+def converter_pydantic(o: Any, f: core.F) -> ast.AST | None:
+    import pydantic
+
+    if not isinstance(o, pydantic.BaseModel):
+        return None
+
+    args = list[ast.AST]()
+    for name, field in o.__class__.model_fields.items():
+        value = getattr(o, name, FIELD_MISSING)
+        if value == field.default:
+            continue
+        if field.default_factory and value == field.default_factory():  # type: ignore[call-arg]
+            continue
+        args.append(f(templates.t("{key}={value}", key=templates.t(name), value=value)))
+    return f(templates.t("{c}({args:*})", c=type(o), args=args))
+
+
+@core.upcast_expr
+def converter_typeform(o: Any, f: core.F) -> ast.AST | None:
+    if o is Annotated:
+        return f(templates.t("Annotated"))
+    if (origin := get_origin(o)) is not None:
+        if origin is Union or origin is UnionType:
+            a, b, *rest = get_args(o)
+            union = f(templates.t("{a} | {b}", a=a, b=b))
+            while rest:
+                b, *rest = rest
+                union = f(templates.t("{a} | {b}", a=union, b=f(b)))
+            return union
+        slice = [f(arg) for arg in get_args(o)]
+        return f(templates.t("{a}[{b:*}]", a=origin, b=slice))
+
+    return None
+
+
+def converter_template(o: Any, f: core.F) -> ast.AST | None:
+    if not isinstance(o, templates.TemplateLike):
+        return None
+
+    o = templates.Template.from_templatelike(o)
+    parts = list[str]()
+    map = NameNodeMap()
+    separator: str = ", "
+    for part in o.parts:
+        if isinstance(part, str):
+            parts.append(part)
+            separator = _trailing_indent(part)
+        else:
+            assert isinstance(part, templates.Interpolation)
+            if part.format_spec == "*":
+                if not isinstance(part.value, list):
+                    raise core.TrolskgenError(f"Can only splat lists of values, not: {part.value!r}")
+                v = [f(n) for n in part.value]
+            else:
+                v = [f(part.value)]
+
+            for i, u in enumerate(v):
+                if (named := _named(u)) is None:
+                    name = map.insert(u)
+                    parts.append(name)
+                else:
+                    parts.append(named.name)
+                    if named.annotation is not None:
+                        name = map.insert(named.annotation)
+                        parts.append(f": {name}")
+                    if named.value is not None:
+                        name = map.insert(named.value)
+                        parts.append(f" = {name}")
+                if i != len(v) - 1:
+                    parts.append(separator)
+
+    node_template = textwrap.dedent("".join(parts)).strip()
+    try:
+        node = ast.parse(node_template)
+    except SyntaxError as e:
+        raise core.TrolskgenError(f"SyntaxError with template:\n\n{node_template}") from e
+
+    _ast_replace(node, map)
+    assert not map.map
+    return node
+
+
+# `converter_template` replacement helpers
+
+
+class NameNodeMap:
+    def __init__(self) -> None:
+        self.i = -1
+        self.map = dict[str, ast.AST]()
+
+    def insert(self, v: ast.AST) -> str:
+        self.i += 1
+        name = f"__tg_{self.i}"
+        self.map[name] = v
+        return name
+
+    def pop(self, v: ast.AST | str) -> ast.AST | None:
+        if isinstance(v, ast.Expr):
+            v = v.value
+        if isinstance(v, ast.Name):
+            v = v.id
+        if isinstance(v, str) and v in self.map:
+            return self.map.pop(v)
+        return None
+
+
+def _is_instance(v: ASTValue, t: type[T]) -> TypeIs[T]:
+    """`isinstance`, but handles `t = list[T], t = A | B`"""
+    if get_origin(t) is list:
+        [t_inner] = get_args(t)
+        return isinstance(v, list) and all(_is_instance(u, t_inner) for u in v)
+    if get_origin(t) is Union:
+        return any(_is_instance(v, t_inner) for t_inner in get_args(t))
+
+    return isinstance(v, t)
+
+
+def _downcast(t: type[T], v: ASTValue) -> T:
+    """Keep removing layers of AST until hopefully, `_is_instance(v, t)`."""
+    v_original = v
+    while not _is_instance(v, t):
+        if isinstance(v, list) and get_origin(t) is list:
+            [r] = get_args(t)
+            return cast(T, [_downcast(r, u) for u in v])
+        if isinstance(v, ast.Module):
+            v = v.body
+        elif isinstance(v, list) and len(v) == 1:
+            v = v[0]
+        elif isinstance(v, ast.Expr):
+            v = v.value
+        elif isinstance(v, ast.Name):
+            v = v.id
+        else:
+            raise core.TrolskgenError(f"Cannot convert {v_original!r} to {t!r}, got as far as {v!r}")
+    return v
+
+
+@dataclass
+class _Named:
+    name: str
+    annotation: ast.expr | None
+    value: ast.expr | None
+
+
+def _named(v: ast.AST) -> _Named | None:
+    """Convert eg. `a: int = 1` to `Named("a", int, 1)`."""
+    if isinstance(v, ast.Module) and len(v.body) == 1:
+        v = v.body[0]
+    if isinstance(v, ast.Assign) and len(v.targets) == 1 and isinstance(v.targets[0], ast.Name):
+        return _Named(v.targets[0].id, None, v.value)
+    if isinstance(v, ast.AnnAssign) and isinstance(v.target, ast.Name):
+        return _Named(v.target.id, v.annotation, v.value)
+    return None
+
+
+def _trailing_indent(part: str) -> str:
+    """Get the trailing indent of a part.
+
+    If previous to the newline, there was a comma, assume we're in a
+    comma separated list.
+    """
+    lines = part.splitlines()
+    try:
+        trailing_comma = lines[-2][-1] == ","
+    except IndexError:
+        trailing_comma = False
+    if all(c == " " for c in lines[-1]) and not trailing_comma:
+        return "\n" + lines[-1]
+    return ", "
+
+
+def _ast_replace(node: ast.AST, map: NameNodeMap) -> None:
+    """Traverse the AST, replacing nodes with items from the `map`."""
+    type_map = ast_types.FIELD_MAPS.get(type(node))
+    if not type_map:
+        return
+
+    for name, t in type_map.items():
+        v = getattr(node, name)
+
+        if (interpolation := map.pop(v)) is not None:
+            v = interpolation
+        elif isinstance(v, list):
+            for i, u in enumerate(v):
+                if (interpolation := map.pop(u)) is not None:
+                    v[i] = interpolation
+
+        v = _downcast(t, v)
+        setattr(node, name, v)
+
+        # recurse
+        if isinstance(v, list):
+            for u in v:
+                _ast_replace(u, map)
+        else:
+            _ast_replace(v, map)