guppylang-internals 0.26.0__py3-none-any.whl → 0.28.0__py3-none-any.whl

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.26.0"
+__version__ = "0.28.0"

guppylang_internals/ast_util.py

@@ -97,13 +97,13 @@ def find_nodes(
 def name_nodes_in_ast(node: Any) -> list[ast.Name]:
     """Returns all `Name` nodes occurring in an AST."""
     found = find_nodes(lambda n: isinstance(n, ast.Name), node)
-    return cast(list[ast.Name], found)
+    return cast("list[ast.Name]", found)
 
 
 def return_nodes_in_ast(node: Any) -> list[ast.Return]:
     """Returns all `Return` nodes occurring in an AST."""
     found = find_nodes(lambda n: isinstance(n, ast.Return), node, {ast.FunctionDef})
-    return cast(list[ast.Return], found)
+    return cast("list[ast.Return]", found)
 
 
 def loop_in_ast(node: Any) -> list[ast.For | ast.While]:
@@ -111,7 +111,7 @@ def loop_in_ast(node: Any) -> list[ast.For | ast.While]:
     found = find_nodes(
         lambda n: isinstance(n, ast.For | ast.While), node, {ast.FunctionDef}
     )
-    return cast(list[ast.For | ast.While], found)
+    return cast("list[ast.For | ast.While]", found)
 
 
 def breaks_in_loop(node: Any) -> list[ast.Break]:
@@ -122,7 +122,7 @@ def breaks_in_loop(node: Any) -> list[ast.Break]:
     found = find_nodes(
         lambda n: isinstance(n, ast.Break), node, {ast.For, ast.While, ast.FunctionDef}
     )
-    return cast(list[ast.Break], found)
+    return cast("list[ast.Break]", found)
 
 
 def loop_controls_in_loop(node: Any) -> list[ast.Break | ast.Continue]:
@@ -135,7 +135,7 @@ def loop_controls_in_loop(node: Any) -> list[ast.Break | ast.Continue]:
         node,
         {ast.For, ast.While, ast.FunctionDef},
     )
-    return cast(list[ast.Break | ast.Continue], found)
+    return cast("list[ast.Break | ast.Continue]", found)
 
 
 class ContextAdjuster(ast.NodeTransformer):
@@ -147,7 +147,7 @@ class ContextAdjuster(ast.NodeTransformer):
         self.ctx = ctx
 
     def visit(self, node: ast.AST) -> ast.AST:
-        return cast(ast.AST, super().visit(node))
+        return cast("ast.AST", super().visit(node))
 
     def visit_Name(self, node: ast.Name) -> ast.Name:
         return with_loc(node, ast.Name(id=node.id, ctx=self.ctx))
@@ -156,29 +156,48 @@ class ContextAdjuster(ast.NodeTransformer):
         self,
         node: ast.Starred,
     ) -> ast.Starred:
-        return with_loc(node, ast.Starred(value=self.visit(node.value), ctx=self.ctx))
+        return with_loc(
+            node,
+            ast.Starred(value=self.visit(node.value), ctx=self.ctx),  # type: ignore[arg-type]
+        )
 
     def visit_Tuple(self, node: ast.Tuple) -> ast.Tuple:
         return with_loc(
-            node, ast.Tuple(elts=[self.visit(elt) for elt in node.elts], ctx=self.ctx)
+            node,
+            ast.Tuple(
+                elts=[self.visit(elt) for elt in node.elts],  # type: ignore[misc]
+                ctx=self.ctx,
+            ),
         )
 
     def visit_List(self, node: ast.List) -> ast.List:
         return with_loc(
-            node, ast.List(elts=[self.visit(elt) for elt in node.elts], ctx=self.ctx)
+            node,
+            ast.List(
+                elts=[self.visit(elt) for elt in node.elts],  # type: ignore[misc]
+                ctx=self.ctx,
+            ),
         )
 
     def visit_Subscript(self, node: ast.Subscript) -> ast.Subscript:
         # Don't adjust the slice!
         return with_loc(
             node,
-            ast.Subscript(value=self.visit(node.value), slice=node.slice, ctx=self.ctx),
+            ast.Subscript(
+                value=self.visit(node.value),  # type: ignore[arg-type]
+                slice=node.slice,
+                ctx=self.ctx,
+            ),
         )
 
     def visit_Attribute(self, node: ast.Attribute) -> ast.Attribute:
         return with_loc(
             node,
-            ast.Attribute(value=self.visit(node.value), attr=node.attr, ctx=self.ctx),
+            ast.Attribute(
+                value=self.visit(node.value),  # type: ignore[arg-type]
+                attr=node.attr,
+                ctx=self.ctx,
+            ),
         )
 
 
@@ -240,15 +259,15 @@ def template_replace(
 
 def line_col(node: ast.AST) -> tuple[int, int]:
     """Returns the line and column of an ast node."""
-    return node.lineno, node.col_offset
+    return node.lineno, node.col_offset  # type: ignore[attr-defined]
 
 
 def set_location_from(node: ast.AST, loc: ast.AST) -> None:
     """Copy source location from one AST node to the other."""
-    node.lineno = loc.lineno
-    node.col_offset = loc.col_offset
-    node.end_lineno = loc.end_lineno
-    node.end_col_offset = loc.end_col_offset
+    node.lineno = loc.lineno  # type: ignore[attr-defined]
+    node.col_offset = loc.col_offset  # type: ignore[attr-defined]
+    node.end_lineno = loc.end_lineno  # type: ignore[attr-defined]
+    node.end_col_offset = loc.end_col_offset  # type: ignore[attr-defined]
 
     source, file, line_offset = get_source(loc), get_file(loc), get_line_offset(loc)
     assert source is not None
@@ -341,11 +360,11 @@ def with_type(ty: "Type", node: A) -> A:
 
 def get_type_opt(node: AstNode) -> Optional["Type"]:
     """Tries to retrieve a type annotation from an AST node."""
-    from guppylang_internals.tys.ty import Type, TypeBase
+    from guppylang_internals.tys.ty import TypeBase
 
     try:
         ty = node.type  # type: ignore[union-attr]
-        return cast(Type, ty) if isinstance(ty, TypeBase) else None
+        return cast("Type", ty) if isinstance(ty, TypeBase) else None
     except AttributeError:
         return None
 

guppylang_internals/cfg/analysis.py

@@ -11,7 +11,7 @@ T = TypeVar("T")
 Result = dict[BB, T]
 
 
-class Analysis(Generic[T], ABC):
+class Analysis(ABC, Generic[T]):
     """Abstract base class for a program analysis pass over the lattice `T`"""
 
     def eq(self, t1: T, t2: T, /) -> bool:
@@ -39,7 +39,7 @@ class Analysis(Generic[T], ABC):
         """
 
 
-class ForwardAnalysis(Generic[T], Analysis[T], ABC):
+class ForwardAnalysis(Analysis[T], ABC, Generic[T]):
     """Abstract base class for a program analysis pass running in forward direction."""
 
     @abstractmethod
@@ -71,7 +71,7 @@ class ForwardAnalysis(Generic[T], Analysis[T], ABC):
         return vals_before
 
 
-class BackwardAnalysis(Generic[T], Analysis[T], ABC):
+class BackwardAnalysis(Analysis[T], ABC, Generic[T]):
     """Abstract base class for a program analysis pass running in backward direction."""
 
     @abstractmethod
@@ -105,7 +105,7 @@ class BackwardAnalysis(Generic[T], Analysis[T], ABC):
 LivenessDomain = dict[VId, BB]
 
 
-class LivenessAnalysis(Generic[VId], BackwardAnalysis[LivenessDomain[VId]]):
+class LivenessAnalysis(BackwardAnalysis[LivenessDomain[VId]], Generic[VId]):
     """Live variable analysis pass.
 
     Computes the variables that are live before the execution of each BB. The analysis
@@ -143,7 +143,7 @@ class LivenessAnalysis(Generic[VId], BackwardAnalysis[LivenessDomain[VId]]):
 
     def apply_bb(self, live_after: LivenessDomain[VId], bb: BB) -> LivenessDomain[VId]:
         stats = self.stats[bb]
-        return {x: bb for x in stats.used} | {
+        return dict.fromkeys(stats.used, bb) | {
             x: b for x, b in live_after.items() if x not in stats.assigned
         }
 
@@ -159,7 +159,7 @@ MaybeAssignmentDomain = set[VId]
 AssignmentDomain = tuple[DefAssignmentDomain[VId], MaybeAssignmentDomain[VId]]
 
 
-class AssignmentAnalysis(Generic[VId], ForwardAnalysis[AssignmentDomain[VId]]):
+class AssignmentAnalysis(ForwardAnalysis[AssignmentDomain[VId]], Generic[VId]):
     """Assigned variable analysis pass.
 
     Computes the set of variables (i.e. `V`s) that are definitely assigned at the start

guppylang_internals/cfg/builder.py

@@ -154,27 +154,52 @@ class CFGBuilder(AstVisitor[BB | None]):
         return bb_opt
 
     def _build_node_value(self, node: BBStatement, bb: BB) -> BB:
-        """Utility method for building a node containing a `value` expression.
+        """Utility method for building a nodes `value` expression, if available.
 
         Builds the expression and mutates `node.value` to point to the built expression.
-        Returns the BB in which the expression is available and adds the node to it.
+        Returns the BB in which the expression is available.
         """
         if (
             not isinstance(node, NestedFunctionDef | ModifiedBlock)
             and node.value is not None
         ):
             node.value, bb = ExprBuilder.build(node.value, self.cfg, bb)
-        bb.statements.append(node)
+        return bb
+
+    def _build_node_targets(self, node: BBStatement, bb: BB) -> BB:
+        """Utility method for building a nodes `target` or `targets` expressions,
+        depending on the node type.
+
+        Builds the expressions and mutates the elements of `node.targets` to point to
+        the built expressions. Returns the BB in which the expressions are available.
+        """
+        if isinstance(node, ast.Assign):
+            for i, target in enumerate(node.targets):
+                node.targets[i], bb = ExprBuilder.build(target, self.cfg, bb)
+        elif isinstance(node, ast.AugAssign | ast.AnnAssign):
+            new_target, bb = ExprBuilder.build(node.target, self.cfg, bb)
+            if not isinstance(new_target, ast.Name | ast.Attribute | ast.Subscript):
+                raise InternalGuppyError("Unexpected type for built expression.")
+            node.target = new_target
         return bb
 
     def visit_Assign(self, node: ast.Assign, bb: BB, jumps: Jumps) -> BB | None:
-        return self._build_node_value(node, bb)
+        bb = self._build_node_value(node, bb)
+        bb = self._build_node_targets(node, bb)
+        bb.statements.append(node)
+        return bb
 
     def visit_AugAssign(self, node: ast.AugAssign, bb: BB, jumps: Jumps) -> BB | None:
-        return self._build_node_value(node, bb)
+        bb = self._build_node_value(node, bb)
+        bb = self._build_node_targets(node, bb)
+        bb.statements.append(node)
+        return bb
 
     def visit_AnnAssign(self, node: ast.AnnAssign, bb: BB, jumps: Jumps) -> BB | None:
-        return self._build_node_value(node, bb)
+        bb = self._build_node_value(node, bb)
+        bb = self._build_node_targets(node, bb)
+        bb.statements.append(node)
+        return bb
 
     def visit_Expr(self, node: ast.Expr, bb: BB, jumps: Jumps) -> BB | None:
         # This is an expression statement where the value is discarded
@@ -262,6 +287,7 @@ class CFGBuilder(AstVisitor[BB | None]):
 
     def visit_Return(self, node: ast.Return, bb: BB, jumps: Jumps) -> BB | None:
         bb = self._build_node_value(node, bb)
+        bb.statements.append(node)
         self.cfg.link(bb, jumps.return_bb)
         return None
 
@@ -572,7 +598,7 @@ class BranchBuilder(AstVisitor[None]):
                     comparators[:-1], node.ops, comparators[1:], strict=True
                 )
             ]
-            conj = ast.BoolOp(op=ast.And(), values=values)
+            conj = ast.BoolOp(op=ast.And(), values=values)  # type: ignore[arg-type]
             set_location_from(conj, node)
             self.visit_BoolOp(conj, bb, true_bb, false_bb)
         else:
@@ -668,6 +694,9 @@ def is_comptime_expression(node: ast.AST) -> ComptimeExpr | None:
 
     Otherwise, returns `None`.
     """
+    if isinstance(node, ComptimeExpr):
+        return node
+
     if (
         isinstance(node, ast.Call)
         and isinstance(node.func, ast.Name)
@@ -679,8 +708,8 @@ def is_comptime_expression(node: ast.AST) -> ComptimeExpr | None:
             case [arg]:
                 pass
             case args:
-                arg = with_loc(node, ast.Tuple(elts=args, ctx=ast.Load))
-        return with_loc(node, ComptimeExpr(value=arg))
+                arg = with_loc(node, ast.Tuple(elts=args, ctx=ast.Load))  # type: ignore[arg-type]
+        return with_loc(node, ComptimeExpr(arg))
     return None
 
 
@@ -701,7 +730,7 @@ def is_illegal_in_list_comp(node: ast.AST) -> bool:
 
 def make_var(name: str, loc: ast.AST | None = None) -> ast.Name:
     """Creates an `ast.Name` node."""
-    node = ast.Name(id=name, ctx=ast.Load)
+    node = ast.Name(id=name, ctx=ast.Load)  # type: ignore[arg-type]
     if loc is not None:
         set_location_from(node, loc)
     return node
@@ -715,5 +744,8 @@ def make_assign(lhs: list[ast.AST], value: ast.expr) -> ast.Assign:
     if len(lhs) == 1:
         target = lhs[0]
     else:
-        target = with_loc(value, ast.Tuple(elts=lhs, ctx=ast.Store()))
-    return with_loc(value, ast.Assign(targets=[target], value=value))
+        target = with_loc(
+            value,
+            ast.Tuple(elts=lhs, ctx=ast.Store()),  # type: ignore[arg-type]
+        )
+    return with_loc(value, ast.Assign(targets=[target], value=value))  # type: ignore[list-item]

guppylang_internals/cfg/cfg.py

@@ -118,7 +118,7 @@ class CFG(BaseCFG[BB]):
         # initial value in the liveness analysis. This solves the edge case that
         # borrowed variables should be considered live, even if the exit is actually
         # unreachable (to avoid linearity violations later).
-        inout_live = {x: self.exit_bb for x in inout_vars}
+        inout_live = dict.fromkeys(inout_vars, self.exit_bb)
         self.live_before = LivenessAnalysis(
             stats, initial=inout_live, include_unreachable=True
         ).run(self.bbs)

guppylang_internals/checker/core.py

@@ -384,7 +384,7 @@ class Globals:
             case _:
                 return assert_never(ty)
 
-        type_defn = cast(TypeDef, ENGINE.get_checked(type_defn.id))
+        type_defn = cast("TypeDef", ENGINE.get_checked(type_defn.id))
         if type_defn.id in DEF_STORE.impls and name in DEF_STORE.impls[type_defn.id]:
             def_id = DEF_STORE.impls[type_defn.id][name]
             defn = ENGINE.get_parsed(def_id)

guppylang_internals/checker/errors/comptime_errors.py

@@ -44,18 +44,6 @@ class ComptimeExprIncoherentListError(Error):
     span_label: ClassVar[str] = "List contains elements with different types"
 
 
-@dataclass(frozen=True)
-class TketNotInstalled(Error):
-    title: ClassVar[str] = "Tket not installed"
-    span_label: ClassVar[str] = (
-        "Experimental pytket compatibility requires `tket` to be installed"
-    )
-
-    @dataclass(frozen=True)
-    class InstallInstruction(Help):
-        message: ClassVar[str] = "Install tket: `pip install tket`"
-
-
 @dataclass(frozen=True)
 class PytketSignatureMismatch(Error):
     title: ClassVar[str] = "Signature mismatch"

guppylang_internals/checker/errors/linearity.py

@@ -33,7 +33,9 @@ class AlreadyUsedError(Error):
 
     @dataclass(frozen=True)
     class PrevUse(Note):
-        span_label: ClassVar[str] = "since it was already {prev_kind.subjunctive} here"
+        span_label: ClassVar[str] = (
+            "{place.describe} already {prev_kind.subjunctive} here"
+        )
         prev_kind: UseKind
 
     @dataclass(frozen=True)
@@ -55,7 +57,9 @@ class ComprAlreadyUsedError(Error):
 
     @dataclass(frozen=True)
     class PrevUse(Note):
-        span_label: ClassVar[str] = "since it was already {prev_kind.subjunctive} here"
+        span_label: ClassVar[str] = (
+            "{place.describe} already {prev_kind.subjunctive} here"
+        )
         prev_kind: UseKind
 
 

guppylang_internals/checker/expr_checker.py

@@ -21,6 +21,7 @@ can be used to infer a type for an expression.
 """
 
 import ast
+import copy
 import sys
 import traceback
 from collections.abc import Sequence
@@ -85,6 +86,7 @@ from guppylang_internals.checker.errors.type_errors import (
     WrongNumberOfArgsError,
 )
 from guppylang_internals.definition.common import Definition
+from guppylang_internals.definition.parameter import ParamDef
 from guppylang_internals.definition.ty import TypeDef
 from guppylang_internals.definition.value import CallableDef, ValueDef
 from guppylang_internals.error import (
@@ -234,7 +236,7 @@ class ExprChecker(AstVisitor[tuple[ast.expr, Subst]]):
         if actual := get_type_opt(expr):
             expr, subst, inst = check_type_against(actual, ty, expr, self.ctx, kind)
             if inst:
-                expr = with_loc(expr, TypeApply(value=expr, tys=inst))
+                expr = with_loc(expr, TypeApply(expr, inst))
             return with_type(ty.substitute(subst), expr), subst
 
         # When checking against a variable, we have to synthesize
@@ -370,7 +372,7 @@ class ExprChecker(AstVisitor[tuple[ast.expr, Subst]]):
 
         # Apply instantiation of quantified type variables
         if inst:
-            node = with_loc(node, TypeApply(value=node, inst=inst))
+            node = with_loc(node, TypeApply(node, inst))
 
         return node, subst
 
@@ -407,23 +409,27 @@ class ExprSynthesizer(AstVisitor[tuple[ast.expr, Type]]):
             raise GuppyError(IllegalConstant(node, type(node.value)))
         return node, ty
 
+    def _check_generic_param(self, name: str, node: ast.expr) -> tuple[ast.expr, Type]:
+        """Helper method to check a generic parameter (ConstParam or TypeParam)."""
+        param = self.ctx.generic_params[name]
+        match param:
+            case ConstParam() as param:
+                ast_node = with_loc(node, GenericParamValue(id=name, param=param))
+                return ast_node, param.ty
+            case TypeParam() as param:
+                raise GuppyError(
+                    ExpectedError(node, "a value", got=f"type `{param.name}`")
+                )
+            case _:
+                return assert_never(param)
+
     def visit_Name(self, node: ast.Name) -> tuple[ast.expr, Type]:
         x = node.id
         if x in self.ctx.locals:
             var = self.ctx.locals[x]
             return with_loc(node, PlaceNode(place=var)), var.ty
         elif x in self.ctx.generic_params:
-            param = self.ctx.generic_params[x]
-            match param:
-                case ConstParam() as param:
-                    ast_node = with_loc(node, GenericParamValue(id=x, param=param))
-                    return ast_node, param.ty
-                case TypeParam() as param:
-                    raise GuppyError(
-                        ExpectedError(node, "a value", got=f"type `{param.name}`")
-                    )
-                case _:
-                    return assert_never(param)
+            return self._check_generic_param(x, node)
         elif x in self.ctx.globals:
             match self.ctx.globals[x]:
                 case Definition() as defn:
@@ -454,6 +460,16 @@ class ExprSynthesizer(AstVisitor[tuple[ast.expr, Type]]):
                 defn, "__new__"
             ):
                 return with_loc(node, GlobalName(id=name, def_id=constr.id)), constr.ty
+            # Handle parameter definitions (e.g., nat_var) that may be imported
+            case ParamDef():
+                # Check if this parameter is in our generic_params
+                # (e.g., used in type signature)
+                if name in self.ctx.generic_params:
+                    return self._check_generic_param(name, node)
+                # If not in generic_params, it's being used outside its scope
+                raise GuppyError(
+                    ExpectedError(node, "a value", got=f"{defn.description} `{name}`")
+                )
             case defn:
                 raise GuppyError(
                     ExpectedError(node, "a value", got=f"{defn.description} `{name}`")
@@ -461,6 +477,7 @@ class ExprSynthesizer(AstVisitor[tuple[ast.expr, Type]]):
 
     def visit_Attribute(self, node: ast.Attribute) -> tuple[ast.expr, Type]:
         from guppylang.defs import GuppyDefinition
+
         from guppylang_internals.engine import ENGINE
 
         # A `value.attr` attribute access. Unfortunately, the `attr` is just a string,
@@ -993,11 +1010,13 @@ def type_check_args(
         new_args.append(a)
     assert next(comptime_args, None) is None
 
-    # If the argument check succeeded, this means that we must have found instantiations
-    # for all unification variables occurring in the input types
-    assert all(
-        set.issubset(inp.ty.unsolved_vars, subst.keys()) for inp in func_ty.inputs
-    )
+    # Check whether we have found instantiations for all unification variables occurring
+    # in the input types
+    for inp in func_ty.inputs:
+        if not set.issubset(inp.ty.unsolved_vars, subst.keys()):
+            raise GuppyTypeInferenceError(
+                TypeInferenceError(node, inp.ty.substitute(subst))
+            )
 
     # We also have to check that we found instantiations for all vars in the return type
     if not set.issubset(func_ty.output.unsolved_vars, subst.keys()):
@@ -1162,19 +1181,25 @@ def check_call(
     #  However the bad case, e.g. `x: int = foo(foo(...foo(?)...))`, shouldn't be common
     #  in practice. Can we do better than that?
 
-    # First, try to synthesize
-    res: tuple[Type, Inst] | None = None
+    # synthesize_call may modify args and node in place,
+    # hence we deepcopy them before passing in the function
+    node_copy = copy.deepcopy(node)
+    inputs_copy = copy.deepcopy(inputs)
+
     try:
         inputs, synth, inst = synthesize_call(func_ty, inputs, node, ctx)
-        res = synth, inst
-    except GuppyTypeInferenceError:
-        pass
-    if res is not None:
-        synth, inst = res
         subst = unify(ty, synth, {})
         if subst is None:
             raise GuppyTypeError(TypeMismatchError(node, ty, synth, kind))
-        return inputs, subst, inst
+        else:
+            return inputs, subst, inst
+    except GuppyTypeInferenceError:
+        pass
+
+    # Restore the state of these values from before they were potentially
+    # modified by `synthesize_call`.
+    inputs = inputs_copy
+    node = node_copy
 
     # If synthesis fails, we try again, this time also using information from the
     # expected return type
@@ -1263,7 +1288,7 @@ def instantiate_poly(node: ast.expr, ty: FunctionType, inst: Inst) -> ast.expr:
             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))
+            node = with_loc(node, TypeApply(with_type(ty, node), inst))
         return with_type(ty.instantiate(inst), node)
     return with_type(ty, node)
 
@@ -1389,7 +1414,7 @@ def python_value_to_guppy_type(
             ]
             if any(ty is None for ty in tys):
                 return None
-            return TupleType(cast(list[Type], tys))
+            return TupleType(cast("list[Type]", tys))
         case list():
             return _python_list_to_guppy_type(v, node, globals, type_hint)
         case None:

guppylang_internals/checker/func_checker.py

@@ -141,7 +141,7 @@ def check_global_func_def(
     check_invalid_under_dagger(func_def, ty.unitary_flags)
     cfg = CFGBuilder().build(func_def.body, returns_none, globals, ty.unitary_flags)
     inputs = [
-        Variable(cast(str, inp.name), inp.ty, loc, inp.flags, is_func_input=True)
+        Variable(cast("str", inp.name), inp.ty, loc, inp.flags, is_func_input=True)
         for inp, loc in zip(ty.inputs, args, strict=True)
         # Comptime inputs are turned into generic args, so are not included here
         if InputFlags.Comptime not in inp.flags
@@ -199,7 +199,7 @@ def check_nested_func_def(
 
     # Construct inputs for checking the body CFG
     inputs = [v for v, _ in captured.values()] + [
-        Variable(cast(str, inp.name), inp.ty, arg, inp.flags, is_func_input=True)
+        Variable(cast("str", inp.name), inp.ty, arg, inp.flags, is_func_input=True)
         for arg, inp in zip(func_def.args.args, func_ty.inputs, strict=True)
         # Comptime inputs are turned into generic args, so are not included here
         if InputFlags.Comptime not in inp.flags
@@ -214,6 +214,7 @@ def check_nested_func_def(
         if not captured:
             # If there are no captured vars, we treat the function like a global name
             from guppylang.defs import GuppyDefinition
+
             from guppylang_internals.definition.function import ParsedFunctionDef
 
             func = ParsedFunctionDef(def_id, func_def.name, func_def, func_ty, None)
@@ -288,7 +289,7 @@ def check_signature(
     # Figure out if this is a method
     self_defn: TypeDef | None = None
     if def_id is not None and def_id in DEF_STORE.impl_parents:
-        self_defn = cast(TypeDef, ENGINE.get_checked(DEF_STORE.impl_parents[def_id]))
+        self_defn = cast("TypeDef", ENGINE.get_checked(DEF_STORE.impl_parents[def_id]))
         assert isinstance(self_defn, TypeDef)
 
     inputs = []

guppylang_internals/checker/stmt_checker.py

@@ -478,7 +478,7 @@ def parse_unpack_pattern(lhs: ast.Tuple | ast.List) -> UnpackPattern:
     # that there is at most one starred expression)
     left = list(takewhile(lambda e: not isinstance(e, ast.Starred), lhs.elts))
     starred = (
-        cast(ast.Starred, lhs.elts[len(left)]).value
+        cast("ast.Starred", lhs.elts[len(left)]).value
         if len(left) < len(lhs.elts)
         else None
     )

guppylang_internals/compiler/cfg_compiler.py

@@ -111,7 +111,7 @@ def compile_bb(
         pred_ty = builder.hugr.port_type(branch_port.out_port())
         assert pred_ty == OpaqueBool
         branch_port = dfg.builder.add_op(read_bool(), branch_port)
-        branch_port = cast(Wire, branch_port)
+        branch_port = cast("Wire", branch_port)
     else:
         # Even if we don't branch, we still have to add a `Sum(())` predicates
         branch_port = dfg.builder.add_op(ops.Tag(0, ht.UnitSum(1)))

guppylang_internals/compiler/core.py

@@ -31,12 +31,14 @@ from guppylang_internals.definition.common import (
     CompilableDef,
     CompiledDef,
     DefId,
+    Definition,
     MonomorphizableDef,
+    RawDef,
 )
 from guppylang_internals.definition.ty import TypeDef
 from guppylang_internals.definition.value import CompiledCallableDef
 from guppylang_internals.diagnostic import Error
-from guppylang_internals.engine import ENGINE
+from guppylang_internals.engine import DEF_STORE, ENGINE
 from guppylang_internals.error import GuppyError, InternalGuppyError
 from guppylang_internals.std._internal.compiler.tket_exts import GUPPY_EXTENSION
 from guppylang_internals.tys.arg import ConstArg, TypeArg
@@ -199,7 +201,7 @@ class CompilerContext(ToHugrContext):
                     params, type_args, self
                 )
                 compile_outer = lambda: monomorphizable.monomorphize(  # noqa: E731 (assign-lambda)
-                    self.module, mono_args, self
+                    self.module, mono_args, self, get_parent_type(monomorphizable)
                 )
             case CompilableDef() as compilable:
                 compile_outer = lambda: compilable.compile_outer(self.module, self)  # noqa: E731
@@ -227,7 +229,9 @@ class CompilerContext(ToHugrContext):
                     raise GuppyError(err)
                 # Thus, the partial monomorphization for the entry point is always empty
                 entry_mono_args = tuple(None for _ in params)
-                entry_compiled = defn.monomorphize(self.module, entry_mono_args, self)
+                entry_compiled = defn.monomorphize(
+                    self.module, entry_mono_args, self, get_parent_type(defn)
+                )
             case CompilableDef() as defn:
                 entry_compiled = defn.compile_outer(self.module, self)
             case CompiledDef() as defn:
@@ -371,7 +375,7 @@ class DFContainer:
         ctx: CompilerContext,
         locals: CompiledLocals | None = None,
     ) -> None:
-        generic_builder = cast(DfBase[ops.DfParentOp], builder)
+        generic_builder = cast("DfBase[ops.DfParentOp]", builder)
         if locals is None:
             locals = {}
         self.builder = generic_builder
@@ -467,6 +471,15 @@ def is_return_var(x: str) -> bool:
     return x.startswith("%ret")
 
 
+def get_parent_type(defn: Definition) -> "RawDef | None":
+    """Returns the RawDef registered as the parent of `child` in the DEF_STORE,
+    or None if it has no parent."""
+    if parent_ty_id := DEF_STORE.impl_parents.get(defn.id):
+        return DEF_STORE.raw_defs[parent_ty_id]
+    else:
+        return None
+
+
 def require_monomorphization(params: Sequence[Parameter]) -> set[Parameter]:
     """Returns the subset of type parameters that must be monomorphized before compiling
     to Hugr.