Fix ast deprecation warnings up to Python 3.13.

CHANGES.rst

@@ -3,6 +3,9 @@ Changes
 
 In next release ...
 
+- Fix ``ast`` deprecation warnings up to Python 3.13.
+  (`#430 <https://github.com/malthe/chameleon/issues/430>`_)
+
 - Fix ``load_module`` deprecation warnings for Python >= 3.10.
 
 4.5.4 (2024-04-08)

docs/library.rst

@@ -72,7 +72,7 @@ You can write such a compiler as a closure:
    def uppercase_expression(string):
        def compiler(target, engine):
            uppercased = self.string.uppercase()
-           value = ast.Str(uppercased)
+           value = ast.Constant(uppercased)
            return [ast.Assign(targets=[target], value=value)]
        return compiler
 

src/chameleon/astutil.py

@@ -45,7 +45,7 @@ def subscript(
 ) -> ast.Subscript:
     return ast.Subscript(
         value=value,
-        slice=ast.Index(value=ast.Str(s=name)),
+        slice=ast.Constant(name),
         ctx=ctx,
     )
 

src/chameleon/codegen.py

@@ -2,6 +2,7 @@
 
 import builtins
 import re
+import sys
 import textwrap
 import types
 from ast import AST
@@ -14,6 +15,8 @@
 from ast import Module
 from ast import NodeTransformer
 from ast import alias
+from ast import copy_location
+from ast import fix_missing_locations
 from ast import unparse
 from typing import TYPE_CHECKING
 from typing import Any
@@ -57,18 +60,34 @@ def wrapper(*vargs, **kwargs):
         symbols.update(kwargs)
 
         class Transformer(NodeTransformer):
-            def visit_FunctionDef(self, node) -> AST:
-                name = symbols.get(node.name, self)
-                if name is self:
+            def visit_FunctionDef(self, node: ast.FunctionDef) -> AST:
+                if node.name not in symbols:
                     return self.generic_visit(node)
 
-                return FunctionDef(
-                    name=name,
-                    args=node.args,
-                    body=list(map(self.visit, node.body)),
-                    decorator_list=getattr(node, "decorator_list", []),
-                    lineno=None,
-                )
+                name = symbols[node.name]
+                assert isinstance(name, str)
+                body: list[ast.stmt] = [self.visit(stmt) for stmt in node.body]
+                if sys.version_info >= (3, 12):
+                    # mypy complains if type_params is missing
+                    funcdef = FunctionDef(
+                        name=name,
+                        args=node.args,
+                        body=body,
+                        decorator_list=node.decorator_list,
+                        returns=node.returns,
+                        type_params=node.type_params,
+                    )
+                else:
+                    funcdef = FunctionDef(
+                        name=name,
+                        args=node.args,
+                        body=body,
+                        decorator_list=node.decorator_list,
+                        returns=node.returns,
+                    )
+                copy_location(funcdef, node)
+                fix_missing_locations(funcdef)
+                return funcdef
 
             def visit_Name(self, node: ast.Name) -> AST:
                 value = symbols.get(node.id, self)
@@ -170,15 +189,17 @@ def require(self, value: type[Any] | Hashable) -> ast.Name:
     def visit_Module(self, module: Module) -> AST:
         assert isinstance(module, Module)
         module = super().generic_visit(module)  # type: ignore[assignment]
-        preamble: list[AST] = []
+        preamble: list[ast.stmt] = []
 
         for name, node in self.defines.items():
-            assignment = Assign(targets=[store(name)], value=node, lineno=None)
+            assignment = Assign(targets=[store(name)], value=node)
+            copy_location(assignment, node)
+            fix_missing_locations(assignment)
             preamble.append(self.visit(assignment))
 
-        imports: list[AST] = []
+        imports: list[ast.stmt] = []
         for value, node in self.imports.items():
-            stmt: AST
+            stmt: ast.stmt
 
             if isinstance(value, types.ModuleType):
                 stmt = Import(
@@ -198,7 +219,7 @@ def visit_Module(self, module: Module) -> AST:
 
             imports.append(stmt)
 
-        return Module(imports + preamble + module.body, ())
+        return Module(imports + preamble + module.body, [])
 
     def visit_Comment(self, node: Comment) -> AST:
         self.comments.append(node.text)