guppylang-internals 0.22.0__tar.gz → 0.24.0__tar.gz

guppylang_internals-0.24.0/CHANGELOG.md

@@ -0,0 +1,98 @@
+# Changelog
+
+First release of `guppylang_internals` package containing refactored out internal components
+from `guppylang`.
+
+## [0.24.0](https://github.com/CQCL/guppylang/compare/guppylang-internals-v0.23.0...guppylang-internals-v0.24.0) (2025-09-19)
+
+
+### ⚠ BREAKING CHANGES
+
+* `guppylang_internals.decorator.extend_type` now returns a `GuppyDefinition` by default. To get the previous behaviour of returning the annotated class unchanged, pass `return_class=True`.
+* `TypeDef`s now require a `params` field
+* guppylang_internals.ty.parsing.parse_function_io_types replaced with parse_function_arg_annotation and check_function_arg
+* Significant changes to the WASM decorators, types and operations
+* Deleted `guppylang_internals.nodes.{IterHasNext, IterEnd}`
+* guppylang_internals.tracing.unpacking.update_packed_value now returns a bool signalling whether the operation was successful.
+* `CompilationEngine` now initialises all it's fields
+* Calling `CompilationEngine.reset` no longer nullifies `additional_extensions`
+* `CompilationEngine.register_extension` no longer adds duplicates to the `additional_extensions` list
+
+### Features
+
+* Infer type of `self` arguments ([#1192](https://github.com/CQCL/guppylang/issues/1192)) ([51f5a2b](https://github.com/CQCL/guppylang/commit/51f5a2b3a9b06bc4ab054f32a4d07f7395df8ff4))
+
+
+### Bug Fixes
+
+* Add init to CompilationEngine; don't trash additional_extensions ([#1256](https://github.com/CQCL/guppylang/issues/1256)) ([e413748](https://github.com/CQCL/guppylang/commit/e413748532db3895cab4925a222177a4fa3fd61b))
+* Allow generic specialization of methods ([#1206](https://github.com/CQCL/guppylang/issues/1206)) ([93936cc](https://github.com/CQCL/guppylang/commit/93936cc275c56dd856d11fabc7aac20176304147)), closes [#1182](https://github.com/CQCL/guppylang/issues/1182)
+* Correctly update borrowed values after calls and catch cases where it's impossible ([#1253](https://github.com/CQCL/guppylang/issues/1253)) ([3ec5462](https://github.com/CQCL/guppylang/commit/3ec54627729b49689da006a743e9e2c359cd3728))
+* Fix `nat` constructor in comptime functions ([#1258](https://github.com/CQCL/guppylang/issues/1258)) ([e257b6f](https://github.com/CQCL/guppylang/commit/e257b6fc2fe3793d6d8f63feca83bf5ed6643673))
+* Fix incorrect leak error for borrowing functions in comptime ([#1252](https://github.com/CQCL/guppylang/issues/1252)) ([855244e](https://github.com/CQCL/guppylang/commit/855244e2d5e3aeb04c2028f9f2310dba0e74210a)), closes [#1249](https://github.com/CQCL/guppylang/issues/1249)
+* wasm module updates based on tested lowering ([#1230](https://github.com/CQCL/guppylang/issues/1230)) ([657cea2](https://github.com/CQCL/guppylang/commit/657cea27af00a9c02e8d1a3190db535bbd1e7981))
+
+
+### Miscellaneous Chores
+
+* Delete unused old iterator AST nodes ([#1215](https://github.com/CQCL/guppylang/issues/1215)) ([2310897](https://github.com/CQCL/guppylang/commit/231089750e33cf70754e5218feed64053c558c17))
+
+## [0.23.0](https://github.com/CQCL/guppylang/compare/guppylang-internals-v0.22.0...guppylang-internals-v0.23.0) (2025-08-19)
+
+
+### ⚠ BREAKING CHANGES
+
+* `check_rows_match` no longer takes `globals` Deleted `GlobalShadowError` and `BranchTypeError.GlobalHint`
+
+### Bug Fixes
+
+* Fix globals vs locals scoping behaviour to match Python ([#1169](https://github.com/CQCL/guppylang/issues/1169)) ([a6a91ca](https://github.com/CQCL/guppylang/commit/a6a91ca32ad7c67bf1d733eb26c016a2662256ef))
+* Fix scoping issues with comprehensions in comptime expressions ([#1218](https://github.com/CQCL/guppylang/issues/1218)) ([0b990e2](https://github.com/CQCL/guppylang/commit/0b990e2b006c31352675004aec63a857f03a0793))
+
+
+### Documentation
+
+* use results sequence protocol for simplicity ([#1208](https://github.com/CQCL/guppylang/issues/1208)) ([f9c1aee](https://github.com/CQCL/guppylang/commit/f9c1aee38776c678660ede5495989ac4d75baaeb))
+
+## [0.22.0](https://github.com/CQCL/guppylang/compare/guppylang-internals-v0.21.2...guppylang-internals-v0.22.0) (2025-08-11)
+
+
+### ⚠ BREAKING CHANGES
+
+* RangeChecker has been deleted.
+
+### Features
+
+* Add float parameter inputs to symbolic pytket circuits ([#1105](https://github.com/CQCL/guppylang/issues/1105)) ([34c546c](https://github.com/CQCL/guppylang/commit/34c546c3b5787beb839687fdbf4db8bc94f36c4a)), closes [#1076](https://github.com/CQCL/guppylang/issues/1076)
+* Allow custom start and step in `range` ([#1157](https://github.com/CQCL/guppylang/issues/1157)) ([a1b9333](https://github.com/CQCL/guppylang/commit/a1b9333712c74270d5efaaa72f83d6b09047c068))
+* Improve codegen for array unpacking ([#1106](https://github.com/CQCL/guppylang/issues/1106)) ([f375097](https://github.com/CQCL/guppylang/commit/f3750973a719b03d27668a3ae39f58c8424deffc))
+* Insert drop ops for affine values ([#1090](https://github.com/CQCL/guppylang/issues/1090)) ([083133e](https://github.com/CQCL/guppylang/commit/083133e809873fce265bb78547fc3e519cb66ea1))
+
+
+### Bug Fixes
+
+* Fix builtins mock escaping the tracing scope ([#1161](https://github.com/CQCL/guppylang/issues/1161)) ([a27a5c1](https://github.com/CQCL/guppylang/commit/a27a5c19560d76e46678f846476ea86e873ac8ac))
+
+## [0.21.1](https://github.com/CQCL/guppylang/compare/guppylang-internals-v0.21.0...guppylang-internals-v0.21.1) (2025-08-05)
+
+
+### Bug Fixes
+
+* **guppylang-internals:** Fix circular import for custom decorators ([#1146](https://github.com/CQCL/guppylang/issues/1146)) ([d8474d8](https://github.com/CQCL/guppylang/commit/d8474d8af3d394275268cd3d0754ff06ecb9bcc2)), closes [#1145](https://github.com/CQCL/guppylang/issues/1145)
+* Support `None` value ([#1149](https://github.com/CQCL/guppylang/issues/1149)) ([7f606c7](https://github.com/CQCL/guppylang/commit/7f606c778d98312a0d1c4a9c7a27448c24d80585)), closes [#1148](https://github.com/CQCL/guppylang/issues/1148)
+
+
+### Documentation
+
+* Fix docs build ([#1142](https://github.com/CQCL/guppylang/issues/1142)) ([4dfd575](https://github.com/CQCL/guppylang/commit/4dfd575bcdfdf1e2db4e61f2f406fff27e0c08f7))
+
+## [0.21.0](https://github.com/CQCL/guppylang/compare/guppylang-internals-v0.20.0...guppylang-internals-v0.21.0) (2025-08-04)
+
+
+### ⚠ BREAKING CHANGES
+
+* All compiler-internal and non-userfacing functionality is moved into a new `guppylang_internals` package
+
+### Code Refactoring
+
+* Split up into `guppylang_internals` package ([#1126](https://github.com/CQCL/guppylang/issues/1126)) ([81d50c0](https://github.com/CQCL/guppylang/commit/81d50c0a24f55eca48d62e4b0275ef2126c5e626))

{guppylang_internals-0.22.0 → guppylang_internals-0.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guppylang-internals
-Version: 0.22.0
+Version: 0.24.0
 Summary: Compiler internals for `guppylang` package.
 Author-email: Mark Koch <mark.koch@quantinuum.com>, TKET development team <tket-support@quantinuum.com>
 Maintainer-email: Mark Koch <mark.koch@quantinuum.com>, TKET development team <tket-support@quantinuum.com>
@@ -219,8 +219,8 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Compilers
 Requires-Python: <4,>=3.10
-Requires-Dist: hugr<0.14,>=0.13.0rc1
-Requires-Dist: tket-exts~=0.10.0
+Requires-Dist: hugr~=0.13.1
+Requires-Dist: tket-exts~=0.11.0
 Requires-Dist: typing-extensions<5,>=4.9.0
 Provides-Extra: pytket
 Requires-Dist: pytket>=1.34; extra == 'pytket'
@@ -228,7 +228,7 @@ Description-Content-Type: text/markdown
 
 # guppylang-internals
 
-This packages contains the internals of the Guppy compiler. 
+This packages contains the internals of the Guppy compiler.
 
 See `guppylang` for the package providing the user-facing language frontend.
 
@@ -250,4 +250,4 @@ See [DEVELOPMENT.md] information on how to develop and contribute to this packag
 
 This project is licensed under Apache License, Version 2.0 ([LICENCE][] or http://www.apache.org/licenses/LICENSE-2.0).
 
-  [LICENCE]: https://github.com/CQCL/guppylang/blob/main/LICENCE
+  [LICENCE]: https://github.com/CQCL/guppylang/blob/main/LICENCE

{guppylang_internals-0.22.0 → guppylang_internals-0.24.0}/README.md

@@ -1,6 +1,6 @@
 # guppylang-internals
 
-This packages contains the internals of the Guppy compiler. 
+This packages contains the internals of the Guppy compiler.
 
 See `guppylang` for the package providing the user-facing language frontend.
 
@@ -22,4 +22,4 @@ See [DEVELOPMENT.md] information on how to develop and contribute to this packag
 
 This project is licensed under Apache License, Version 2.0 ([LICENCE][] or http://www.apache.org/licenses/LICENSE-2.0).
 
-  [LICENCE]: https://github.com/CQCL/guppylang/blob/main/LICENCE
+  [LICENCE]: https://github.com/CQCL/guppylang/blob/main/LICENCE

{guppylang_internals-0.22.0 → guppylang_internals-0.24.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "guppylang-internals"
-version = "0.22.0"
+version = "0.24.0"
 requires-python = ">=3.10,<4"
 description = "Compiler internals for `guppylang` package."
 license = { file = "LICENCE" }
@@ -34,8 +34,8 @@ classifiers = [
 
 dependencies = [
     "typing-extensions >=4.9.0,<5",
-    "tket-exts ~= 0.10.0",
-    "hugr >= 0.13.0rc1,<0.14",
+    "tket-exts ~= 0.11.0",
+    "hugr ~= 0.13.1",
 ]
 
 [project.optional-dependencies]

{guppylang_internals-0.22.0 → guppylang_internals-0.24.0}/src/guppylang_internals/__init__.py

@@ -1,3 +1,3 @@
 # This is updated by our release-please workflow, triggered by this
 # annotation: x-release-please-version
-__version__ = "0.22.0"
+__version__ = "0.24.0"

{guppylang_internals-0.22.0 → guppylang_internals-0.24.0}/src/guppylang_internals/cfg/cfg.py

@@ -27,6 +27,9 @@ class BaseCFG(Generic[T]):
     ass_before: Result[DefAssignmentDomain[str]]
     maybe_ass_before: Result[MaybeAssignmentDomain[str]]
 
+    #: Set of variables defined in this CFG
+    assigned_somewhere: set[str]
+
     def __init__(
         self, bbs: list[T], entry_bb: T | None = None, exit_bb: T | None = None
     ):
@@ -38,6 +41,7 @@ class BaseCFG(Generic[T]):
         self.live_before = {}
         self.ass_before = {}
         self.maybe_ass_before = {}
+        self.assigned_somewhere = set()
 
     def ancestors(self, *bbs: T) -> Iterator[T]:
         """Returns an iterator over all ancestors of the given BBs in BFS order."""
@@ -101,6 +105,10 @@ class CFG(BaseCFG[BB]):
         inout_vars: list[str],
     ) -> dict[BB, VariableStats[str]]:
         stats = {bb: bb.compute_variable_stats() for bb in self.bbs}
+        # Locals are variables that are assigned somewhere inside the function
+        self.assigned_somewhere = def_ass_before.union(
+            maybe_ass_before, (x for bb in self.bbs for x in stats[bb].assigned)
+        )
         # Mark all borrowed variables as implicitly used in the exit BB
         stats[self.exit_bb].used |= {x: InoutReturnSentinel(var=x) for x in inout_vars}
         # This also means borrowed variables are always live, so we can use them as the

{guppylang_internals-0.22.0 → guppylang_internals-0.24.0}/src/guppylang_internals/checker/cfg_checker.py

@@ -8,7 +8,7 @@ import ast
 import collections
 from collections.abc import Iterator, Sequence
 from dataclasses import dataclass, field
-from typing import ClassVar, Generic, TypeVar, cast
+from typing import ClassVar, Generic, TypeVar
 
 from guppylang_internals.ast_util import line_col
 from guppylang_internals.cfg.bb import BB
@@ -23,7 +23,6 @@ from guppylang_internals.checker.core import (
 )
 from guppylang_internals.checker.expr_checker import ExprSynthesizer, to_bool
 from guppylang_internals.checker.stmt_checker import StmtChecker
-from guppylang_internals.definition.value import ValueDef
 from guppylang_internals.diagnostic import Error, Note
 from guppylang_internals.error import GuppyError
 from guppylang_internals.tys.param import Parameter
@@ -115,7 +114,7 @@ def check_cfg(
         if bb in compiled:
             # If the BB was already compiled, we just have to check that the signatures
             # match.
-            check_rows_match(input_row, compiled[bb].sig.input_row, bb, globals)
+            check_rows_match(input_row, compiled[bb].sig.input_row, bb)
         else:
             # Otherwise, check the BB and enqueue its successors
             checked_bb = check_bb(
@@ -195,21 +194,6 @@ class BranchTypeError(Error):
         span_label: ClassVar[str] = "This is of type `{ty}`"
         ty: Type
 
-    @dataclass(frozen=True)
-    class GlobalHint(Note):
-        message: ClassVar[str] = (
-            "{ident} may be shadowing a global {defn.description} definition of type "
-            "`{defn.ty}` on some branches"
-        )
-        defn: ValueDef
-
-
-@dataclass(frozen=True)
-class GlobalShadowError(Error):
-    title: ClassVar[str] = "Global variable conditionally shadowed"
-    span_label: ClassVar[str] = "{ident} may be shadowing a global variable"
-    ident: str
-
 
 def check_bb(
     bb: BB,
@@ -245,23 +229,27 @@ def check_bb(
 
     for succ in bb.successors + bb.dummy_successors:
         for x, use_bb in cfg.live_before[succ].items():
-            # Check that the variables requested by the successor are defined
-            if (
-                x not in ctx.locals
-                and x not in ctx.globals
-                and x not in ctx.generic_params
-            ):
-                # If the variable is defined on *some* paths, we can give a more
-                # informative error message
-                if x in cfg.maybe_ass_before[use_bb]:
-                    err = VarMaybeNotDefinedError(use_bb.vars.used[x], x)
-                    if bad_branch := diagnose_maybe_undefined(use_bb, x, cfg):
-                        branch_expr, truth_value = bad_branch
-                        note = VarMaybeNotDefinedError.BadBranch(
-                            branch_expr, x, truth_value
-                        )
-                        err.add_sub_diagnostic(note)
+            # Check that the variables requested by the successor are defined. If `x` is
+            # a local variable, then we must be able to find it in the context.
+            # Following Python, locals are exactly those variables that are defined
+            # somewhere in the function body.
+            if x in cfg.assigned_somewhere:
+                if x not in ctx.locals:
+                    # If the variable is defined on *some* paths, we can give a more
+                    # informative error message
+                    if x in cfg.maybe_ass_before[use_bb]:
+                        err: Error = VarMaybeNotDefinedError(use_bb.vars.used[x], x)
+                        if bad_branch := diagnose_maybe_undefined(use_bb, x, cfg):
+                            branch_expr, truth_value = bad_branch
+                            note = VarMaybeNotDefinedError.BadBranch(
+                                branch_expr, x, truth_value
+                            )
+                            err.add_sub_diagnostic(note)
+                    else:
+                        err = VarNotDefinedError(use_bb.vars.used[x], x)
                     raise GuppyError(err)
+            # If x is not a local, then it must be a global or generic param
+            elif x not in ctx.globals and x not in ctx.generic_params:
                 raise GuppyError(VarNotDefinedError(use_bb.vars.used[x], x))
 
     # Finally, we need to compute the signature of the basic block
@@ -287,9 +275,7 @@ def check_bb(
     return checked_bb
 
 
-def check_rows_match(
-    row1: Row[Variable], row2: Row[Variable], bb: BB, globals: Globals
-) -> None:
+def check_rows_match(row1: Row[Variable], row2: Row[Variable], bb: BB) -> None:
     """Checks that the types of two rows match up.
 
     Otherwise, an error is thrown, alerting the user that a variable has different
@@ -299,10 +285,7 @@ def check_rows_match(
     for x in map1.keys() | map2.keys():
         # If block signature lengths don't match but no undefined error was thrown, some
         # variables may be shadowing global variables.
-        v1 = map1.get(x) or cast(ValueDef, globals[x])
-        assert isinstance(v1, Variable | ValueDef)
-        v2 = map2.get(x) or cast(ValueDef, globals[x])
-        assert isinstance(v2, Variable | ValueDef)
+        v1, v2 = map1[x], map2[x]
         if v1.ty != v2.ty:
             # In the error message, we want to mention the variable that was first
             # defined at the start.
@@ -320,31 +303,9 @@ def check_rows_match(
             # We don't add a location to the type hint for the global variable,
             # since it could lead to cross-file diagnostics (which are not
             # supported) or refer to long function definitions.
-            sub1 = (
-                BranchTypeError.TypeHint(v1.defined_at, v1.ty)
-                if isinstance(v1, Variable)
-                else BranchTypeError.GlobalHint(None, v1)
-            )
-            sub2 = (
-                BranchTypeError.TypeHint(v2.defined_at, v2.ty)
-                if isinstance(v2, Variable)
-                else BranchTypeError.GlobalHint(None, v2)
-            )
-            err.add_sub_diagnostic(sub1)
-            err.add_sub_diagnostic(sub2)
+            err.add_sub_diagnostic(BranchTypeError.TypeHint(v1.defined_at, v1.ty))
+            err.add_sub_diagnostic(BranchTypeError.TypeHint(v2.defined_at, v2.ty))
             raise GuppyError(err)
-        else:
-            # TODO: Remove once https://github.com/CQCL/guppylang/issues/827 is done.
-            # If either is a global variable, don't allow shadowing even if types match.
-            if not (isinstance(v1, Variable) and isinstance(v2, Variable)):
-                local_var = v1 if isinstance(v1, Variable) else v2
-                ident = (
-                    "Expression"
-                    if local_var.name.startswith("%")
-                    else f"Variable `{local_var.name}`"
-                )
-                glob_err = GlobalShadowError(local_var.defined_at, ident)
-                raise GuppyError(glob_err)
 
 
 def diagnose_maybe_undefined(

{guppylang_internals-0.22.0 → guppylang_internals-0.24.0}/src/guppylang_internals/checker/core.py

@@ -54,6 +54,7 @@ from guppylang_internals.tys.ty import (
 
 if TYPE_CHECKING:
     from guppylang_internals.definition.struct import StructField
+    from guppylang_internals.tys.parsing import TypeParsingCtx
 
 
 #: A "place" is a description for a storage location of a local value that users
@@ -507,6 +508,13 @@ class Context(NamedTuple):
     locals: Locals[str, Variable]
     generic_params: dict[str, Parameter]
 
+    @property
+    def parsing_ctx(self) -> "TypeParsingCtx":
+        """A type parsing context derived from this checking context."""
+        from guppylang_internals.tys.parsing import TypeParsingCtx
+
+        return TypeParsingCtx(self.globals, self.generic_params)
+
 
 class DummyEvalDict(dict[str, Any]):
     """A custom dict that can be passed to `eval` to give better error messages.

{guppylang_internals-0.22.0 → guppylang_internals-0.24.0}/src/guppylang_internals/checker/expr_checker.py

@@ -34,6 +34,7 @@ from guppylang_internals.ast_util import (
     AstNode,
     AstVisitor,
     breaks_in_loop,
+    get_type,
     get_type_opt,
     return_nodes_in_ast,
     with_loc,
@@ -101,8 +102,6 @@ from guppylang_internals.nodes import (
     FieldAccessAndDrop,
     GenericParamValue,
     GlobalName,
-    IterEnd,
-    IterHasNext,
     IterNext,
     LocalCall,
     MakeIter,
@@ -784,14 +783,6 @@ class ExprSynthesizer(AstVisitor[tuple[ast.expr, Type]]):
                 raise GuppyTypeError(err)
         return expr, ty
 
-    def visit_IterHasNext(self, node: IterHasNext) -> tuple[ast.expr, Type]:
-        node.value, ty = self.synthesize(node.value)
-        flags = InputFlags.Owned if not ty.copyable else InputFlags.NoFlags
-        exp_sig = FunctionType([FuncInput(ty, flags)], TupleType([bool_type(), ty]))
-        return self.synthesize_instance_func(
-            node.value, [], "__hasnext__", "an iterator", exp_sig, True
-        )
-
     def visit_IterNext(self, node: IterNext) -> tuple[ast.expr, Type]:
         node.value, ty = self.synthesize(node.value)
         flags = InputFlags.Owned if not ty.copyable else InputFlags.NoFlags
@@ -803,14 +794,6 @@ class ExprSynthesizer(AstVisitor[tuple[ast.expr, Type]]):
             node.value, [], "__next__", "an iterator", exp_sig, True
         )
 
-    def visit_IterEnd(self, node: IterEnd) -> tuple[ast.expr, Type]:
-        node.value, ty = self.synthesize(node.value)
-        flags = InputFlags.Owned if not ty.copyable else InputFlags.NoFlags
-        exp_sig = FunctionType([FuncInput(ty, flags)], NoneType())
-        return self.synthesize_instance_func(
-            node.value, [], "__end__", "an iterator", exp_sig, True
-        )
-
     def visit_ListComp(self, node: ast.ListComp) -> tuple[ast.expr, Type]:
         raise InternalGuppyError(
             "BB contains `ListComp`. Should have been removed during CFG"
@@ -946,7 +929,7 @@ def check_type_apply(ty: FunctionType, node: ast.Subscript, ctx: Context) -> Ins
         raise GuppyError(err)
 
     return [
-        param.check_arg(arg_from_ast(arg_expr, globals, ctx.generic_params), arg_expr)
+        param.check_arg(arg_from_ast(arg_expr, ctx.parsing_ctx), arg_expr)
         for arg_expr, param in zip(arg_exprs, ty.params, strict=True)
     ]
 
@@ -1232,7 +1215,14 @@ def instantiate_poly(node: ast.expr, ty: FunctionType, inst: Inst) -> ast.expr:
     """Instantiates quantified type arguments in a function."""
     assert len(ty.params) == len(inst)
     if len(inst) > 0:
-        node = with_loc(node, TypeApply(value=with_type(ty, node), inst=inst))
+        # Partial applications need to be instantiated on the inside
+        if isinstance(node, PartialApply):
+            full_ty = get_type(node.func)
+            assert isinstance(full_ty, FunctionType)
+            assert full_ty.params == ty.params
+            node.func = instantiate_poly(node.func, full_ty, inst)
+        else:
+            node = with_loc(node, TypeApply(value=with_type(ty, node), inst=inst))
         return with_type(ty.instantiate(inst), node)
     return with_type(ty, node)
 
@@ -1309,11 +1299,7 @@ def eval_comptime_expr(node: ComptimeExpr, ctx: Context) -> Any:
         raise GuppyError(ComptimeExprNotCPythonError(node))
 
     try:
-        python_val = eval(  # noqa: S307
-            ast.unparse(node.value),
-            None,
-            DummyEvalDict(ctx, node.value),
-        )
+        python_val = eval(ast.unparse(node.value), DummyEvalDict(ctx, node.value))  # noqa: S307
     except DummyEvalDict.GuppyVarUsedError as e:
         raise GuppyError(ComptimeExprNotStaticError(e.node or node, e.var)) from None
     except Exception as e: