guppylang-internals 0.23.0__py3-none-any.whl → 0.25.0__py3-none-any.whl

guppylang_internals/compiler/modifier_compiler.py

@@ -0,0 +1,174 @@
+"""Hugr generation for modifiers."""
+
+from hugr import Wire, ops
+from hugr import tys as ht
+
+from guppylang_internals.ast_util import get_type
+from guppylang_internals.checker.modifier_checker import non_copyable_front_others_back
+from guppylang_internals.compiler.cfg_compiler import compile_cfg
+from guppylang_internals.compiler.core import CompilerContext, DFContainer
+from guppylang_internals.compiler.expr_compiler import ExprCompiler
+from guppylang_internals.nodes import CheckedModifiedBlock, PlaceNode
+from guppylang_internals.std._internal.compiler.array import (
+    array_new,
+    array_to_std_array,
+    standard_array_type,
+    std_array_to_array,
+    unpack_array,
+)
+from guppylang_internals.std._internal.compiler.tket_exts import MODIFIER_EXTENSION
+from guppylang_internals.tys.builtin import int_type, is_array_type
+from guppylang_internals.tys.ty import InputFlags
+
+
+def compile_modified_block(
+    modified_block: CheckedModifiedBlock,
+    dfg: DFContainer,
+    ctx: CompilerContext,
+    expr_compiler: ExprCompiler,
+) -> Wire:
+    DAGGER_OP_NAME = "DaggerModifier"
+    CONTROL_OP_NAME = "ControlModifier"
+    POWER_OP_NAME = "PowerModifier"
+
+    dagger_op_def = MODIFIER_EXTENSION.get_op(DAGGER_OP_NAME)
+    control_op_def = MODIFIER_EXTENSION.get_op(CONTROL_OP_NAME)
+    power_op_def = MODIFIER_EXTENSION.get_op(POWER_OP_NAME)
+
+    body_ty = modified_block.ty
+    # TODO: Shouldn't this be `to_hugr_poly` since it can contain
+    # a variable with a generic type?
+    hugr_ty = body_ty.to_hugr(ctx)
+    in_out_ht = [
+        fn_inp.ty.to_hugr(ctx)
+        for fn_inp in body_ty.inputs
+        if InputFlags.Inout in fn_inp.flags and InputFlags.Comptime not in fn_inp.flags
+    ]
+    other_in_ht = [
+        fn_inp.ty.to_hugr(ctx)
+        for fn_inp in body_ty.inputs
+        if InputFlags.Inout not in fn_inp.flags
+        and InputFlags.Comptime not in fn_inp.flags
+    ]
+    in_out_arg = ht.ListArg([t.type_arg() for t in in_out_ht])
+    other_in_arg = ht.ListArg([t.type_arg() for t in other_in_ht])
+
+    func_builder = dfg.builder.module_root_builder().define_function(
+        str(modified_block), hugr_ty.input, hugr_ty.output
+    )
+
+    # compile body
+    cfg = compile_cfg(modified_block.cfg, func_builder, func_builder.inputs(), ctx)
+    func_builder.set_outputs(*cfg)
+
+    # LoadFunc
+    call = dfg.builder.load_function(func_builder, hugr_ty)
+
+    # Function inputs
+    captured = [v for v, _ in modified_block.captured.values()]
+    captured = non_copyable_front_others_back(captured)
+    args = [dfg[v] for v in captured]
+
+    # Apply modifiers
+    if modified_block.has_dagger():
+        dagger_ty = ht.FunctionType([hugr_ty], [hugr_ty])
+        call = dfg.builder.add_op(
+            ops.ExtOp(
+                dagger_op_def,
+                dagger_ty,
+                [in_out_arg, other_in_arg],
+            ),
+            call,
+        )
+    if modified_block.has_power():
+        power_ty = ht.FunctionType([hugr_ty, int_type().to_hugr(ctx)], [hugr_ty])
+        for power in modified_block.power:
+            num = expr_compiler.compile(power.iter, dfg)
+            call = dfg.builder.add_op(
+                ops.ExtOp(
+                    power_op_def,
+                    power_ty,
+                    [in_out_arg, other_in_arg],
+                ),
+                call,
+                num,
+            )
+    qubit_num_args = []
+    if modified_block.has_control():
+        for control in modified_block.control:
+            assert control.qubit_num is not None
+            qubit_num: ht.TypeArg
+            if isinstance(control.qubit_num, int):
+                qubit_num = ht.BoundedNatArg(control.qubit_num)
+            else:
+                qubit_num = control.qubit_num.to_arg().to_hugr(ctx)
+            qubit_num_args.append(qubit_num)
+            std_array = standard_array_type(ht.Qubit, qubit_num)
+
+            # control operator
+            input_fn_ty = hugr_ty
+            output_fn_ty = ht.FunctionType(
+                [std_array, *hugr_ty.input], [std_array, *hugr_ty.output]
+            )
+            op = ops.ExtOp(
+                control_op_def,
+                ht.FunctionType([input_fn_ty], [output_fn_ty]),
+                [qubit_num, in_out_arg, other_in_arg],
+            )
+            call = dfg.builder.add_op(op, call)
+            # update types
+            in_out_arg = ht.ListArg([std_array.type_arg(), *in_out_arg.elems])
+            hugr_ty = output_fn_ty
+
+    # Prepare control arguments
+    ctrl_args: list[Wire] = []
+    for i, control in enumerate(modified_block.control):
+        if is_array_type(get_type(control.ctrl[0])):
+            control_array = expr_compiler.compile(control.ctrl[0], dfg)
+            control_array = dfg.builder.add_op(
+                array_to_std_array(ht.Qubit, qubit_num_args[i]), control_array
+            )
+            ctrl_args.append(control_array)
+        else:
+            cs = [expr_compiler.compile(c, dfg) for c in control.ctrl]
+            control_array = dfg.builder.add_op(
+                array_new(ht.Qubit, len(control.ctrl)), *cs
+            )
+            control_array = dfg.builder.add_op(
+                array_to_std_array(ht.Qubit, qubit_num_args[i]), *control_array
+            )
+            ctrl_args.append(control_array)
+
+    # Call
+    call = dfg.builder.add_op(
+        ops.CallIndirect(),
+        call,
+        *ctrl_args,
+        *args,
+    )
+    outports = iter(call)
+
+    # Unpack controls
+    for i, control in enumerate(modified_block.control):
+        outport = next(outports)
+        if is_array_type(get_type(control.ctrl[0])):
+            control_array = dfg.builder.add_op(
+                std_array_to_array(ht.Qubit, qubit_num_args[i]), outport
+            )
+            c = control.ctrl[0]
+            assert isinstance(c, PlaceNode)
+            dfg[c.place] = control_array
+        else:
+            control_array = dfg.builder.add_op(
+                std_array_to_array(ht.Qubit, qubit_num_args[i]), outport
+            )
+            unpacked = unpack_array(dfg.builder, control_array)
+            for c, new_c in zip(control.ctrl, unpacked, strict=False):
+                assert isinstance(c, PlaceNode)
+                dfg[c.place] = new_c
+
+    for arg in captured:
+        if InputFlags.Inout in arg.flags:
+            dfg[arg] = next(outports)
+
+    return call

guppylang_internals/compiler/stmt_compiler.py

@@ -2,7 +2,6 @@ import ast
 import functools
 from collections.abc import Sequence
 
-import hugr.tys as ht
 from hugr import Wire, ops
 from hugr.build.dfg import DfBase
 
@@ -18,6 +17,7 @@ from guppylang_internals.compiler.expr_compiler import ExprCompiler
 from guppylang_internals.error import InternalGuppyError
 from guppylang_internals.nodes import (
     ArrayUnpack,
+    CheckedModifiedBlock,
     CheckedNestedFunctionDef,
     IterableUnpack,
     PlaceNode,
@@ -120,8 +120,9 @@ class StmtCompiler(CompilerBase, AstVisitor[None]):
                 ports[len(left) : -len(right)] if right else ports[len(left) :]
             )
             elt = get_element_type(array_ty).to_hugr(self.ctx)
-            opts = [self.builder.add_op(ops.Some(elt), p) for p in starred_ports]
-            array = self.builder.add_op(array_new(ht.Option(elt), len(opts)), *opts)
+            array = self.builder.add_op(
+                array_new(elt, len(starred_ports)), *starred_ports
+            )
             self._assign(starred, array)
 
     @_assign.register
@@ -130,7 +131,7 @@ class StmtCompiler(CompilerBase, AstVisitor[None]):
         # Given an assignment pattern `left, *starred, right`, pop from the left and
         # right, leaving us with the starred array in the middle
         length = lhs.length
-        opt_elt_ty = ht.Option(lhs.elt_type.to_hugr(self.ctx))
+        elt_ty = lhs.elt_type.to_hugr(self.ctx)
 
         def pop(
             array: Wire, length: int, pats: list[ast.expr], from_left: bool
@@ -141,10 +142,9 @@ class StmtCompiler(CompilerBase, AstVisitor[None]):
             elts = []
             for i in range(num_pats):
                 res = self.builder.add_op(
-                    array_pop(opt_elt_ty, length - i, from_left), array
+                    array_pop(elt_ty, length - i, from_left), array
                 )
-                [elt_opt, array] = build_unwrap(self.builder, res, err)
-                [elt] = build_unwrap(self.builder, elt_opt, err)
+                [elt, array] = build_unwrap(self.builder, res, err)
                 elts.append(elt)
             # Assign elements to the given patterns
             for pat, elt in zip(
@@ -164,7 +164,7 @@ class StmtCompiler(CompilerBase, AstVisitor[None]):
             self._assign(lhs.pattern.starred, array)
         else:
             assert length == 0
-            self.builder.add_op(array_discard_empty(opt_elt_ty), array)
+            self.builder.add_op(array_discard_empty(elt_ty), array)
 
     @_assign.register
     def _assign_iterable(self, lhs: IterableUnpack, port: Wire) -> None:
@@ -221,3 +221,10 @@ class StmtCompiler(CompilerBase, AstVisitor[None]):
         var = Variable(node.name, node.ty, node)
         loaded_func = compile_local_func_def(node, self.dfg, self.ctx)
         self.dfg[var] = loaded_func
+
+    def visit_CheckedModifiedBlock(self, node: CheckedModifiedBlock) -> None:
+        from guppylang_internals.compiler.modifier_compiler import (
+            compile_modified_block,
+        )
+
+        compile_modified_block(node, self.dfg, self.ctx, self.expr_compiler)

guppylang_internals/decorator.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import inspect
-from typing import TYPE_CHECKING, ParamSpec, TypeVar
+from typing import TYPE_CHECKING, ParamSpec, TypeVar, overload
 
 from hugr import ops
 from hugr import tys as ht
@@ -42,6 +42,7 @@ from guppylang_internals.tys.ty import (
 )
 
 if TYPE_CHECKING:
+    import ast
     import builtins
     from collections.abc import Callable, Sequence
     from types import FrameType
@@ -121,15 +122,19 @@ def hugr_op(
     return custom_function(OpCompiler(op), checker, higher_order_value, name, signature)
 
 
-def extend_type(defn: TypeDef) -> Callable[[type], type]:
-    """Decorator to add new instance functions to a type."""
+def extend_type(defn: TypeDef, return_class: bool = False) -> Callable[[type], type]:
+    """Decorator to add new instance functions to a type.
+
+    By default, returns a `GuppyDefinition` object referring to the type. Alternatively,
+    `return_class=True` can be set to return the decorated class unchanged.
+    """
     from guppylang.defs import GuppyDefinition
 
     def dec(c: type) -> type:
         for val in c.__dict__.values():
             if isinstance(val, GuppyDefinition):
                 DEF_STORE.register_impl(defn.id, val.wrapped.name, val.id)
-        return c
+        return c if return_class else GuppyDefinition(defn)  # type: ignore[return-value]
 
     return dec
 
@@ -181,63 +186,124 @@ def custom_type(
 
 
 def wasm_module(
-    filename: str, filehash: int
+    filename: str,
 ) -> Callable[[builtins.type[T]], GuppyDefinition]:
-    from guppylang.defs import GuppyDefinition
-
-    def dec(cls: builtins.type[T]) -> GuppyDefinition:
-        # N.B. Only one module per file and vice-versa
-        wasm_module = WasmModuleTypeDef(
-            DefId.fresh(),
-            cls.__name__,
-            None,
-            filename,
-            filehash,
-        )
-
-        wasm_module_ty = wasm_module.check_instantiate([], None)
-
-        DEF_STORE.register_def(wasm_module, get_calling_frame())
-        for val in cls.__dict__.values():
-            if isinstance(val, GuppyDefinition):
-                DEF_STORE.register_impl(wasm_module.id, val.wrapped.name, val.id)
-        # Add a constructor to the class
-        call_method = CustomFunctionDef(
-            DefId.fresh(),
-            "__new__",
-            None,
-            FunctionType(
-                [FuncInput(NumericType(NumericType.Kind.Nat), flags=InputFlags.Owned)],
-                wasm_module_ty,
-            ),
-            DefaultCallChecker(),
-            WasmModuleInitCompiler(),
-            True,
-            GlobalConstId.fresh(f"{cls.__name__}.__new__"),
-            True,
-        )
-        discard = CustomFunctionDef(
-            DefId.fresh(),
-            "discard",
-            None,
-            FunctionType([FuncInput(wasm_module_ty, InputFlags.Owned)], NoneType()),
-            DefaultCallChecker(),
-            WasmModuleDiscardCompiler(),
-            False,
-            GlobalConstId.fresh(f"{cls.__name__}.__discard__"),
-            True,
-        )
-        DEF_STORE.register_def(call_method, get_calling_frame())
-        DEF_STORE.register_impl(wasm_module.id, "__new__", call_method.id)
-        DEF_STORE.register_def(discard, get_calling_frame())
-        DEF_STORE.register_impl(wasm_module.id, "discard", discard.id)
+    def type_def_wrapper(
+        id: DefId,
+        name: str,
+        defined_at: ast.AST | None,
+        wasm_file: str,
+        config: str | None,
+    ) -> OpaqueTypeDef:
+        assert config is None
+        return WasmModuleTypeDef(id, name, defined_at, wasm_file)
+
+    f = ext_module_decorator(
+        type_def_wrapper, WasmModuleInitCompiler(), WasmModuleDiscardCompiler(), True
+    )
+    return f(filename, None)
 
-        return GuppyDefinition(wasm_module)
-
-    return dec
 
+def ext_module_decorator(
+    type_def: Callable[[DefId, str, ast.AST | None, str, str | None], OpaqueTypeDef],
+    init_compiler: CustomInoutCallCompiler,
+    discard_compiler: CustomInoutCallCompiler,
+    init_arg: bool,  # Whether the init function should take a nat argument
+) -> Callable[[str, str | None], Callable[[builtins.type[T]], GuppyDefinition]]:
+    from guppylang.defs import GuppyDefinition
 
-def wasm(f: Callable[P, T]) -> GuppyFunctionDefinition[P, T]:
+    def fun(
+        filename: str, module: str | None
+    ) -> Callable[[builtins.type[T]], GuppyDefinition]:
+        def dec(cls: builtins.type[T]) -> GuppyDefinition:
+            # N.B. Only one module per file and vice-versa
+            ext_module = type_def(
+                DefId.fresh(),
+                cls.__name__,
+                None,
+                filename,
+                module,
+            )
+
+            ext_module_ty = ext_module.check_instantiate([], None)
+
+            DEF_STORE.register_def(ext_module, get_calling_frame())
+            for val in cls.__dict__.values():
+                if isinstance(val, GuppyDefinition):
+                    DEF_STORE.register_impl(ext_module.id, val.wrapped.name, val.id)
+            # Add a constructor to the class
+            if init_arg:
+                init_fn_ty = FunctionType(
+                    [
+                        FuncInput(
+                            NumericType(NumericType.Kind.Nat),
+                            flags=InputFlags.Owned,
+                        )
+                    ],
+                    ext_module_ty,
+                )
+            else:
+                init_fn_ty = FunctionType([], ext_module_ty)
+
+            call_method = CustomFunctionDef(
+                DefId.fresh(),
+                "__new__",
+                None,
+                init_fn_ty,
+                DefaultCallChecker(),
+                init_compiler,
+                True,
+                GlobalConstId.fresh(f"{cls.__name__}.__new__"),
+                True,
+            )
+            discard = CustomFunctionDef(
+                DefId.fresh(),
+                "discard",
+                None,
+                FunctionType([FuncInput(ext_module_ty, InputFlags.Owned)], NoneType()),
+                DefaultCallChecker(),
+                discard_compiler,
+                False,
+                GlobalConstId.fresh(f"{cls.__name__}.__discard__"),
+                True,
+            )
+            DEF_STORE.register_def(call_method, get_calling_frame())
+            DEF_STORE.register_impl(ext_module.id, "__new__", call_method.id)
+            DEF_STORE.register_def(discard, get_calling_frame())
+            DEF_STORE.register_impl(ext_module.id, "discard", discard.id)
+
+            return GuppyDefinition(ext_module)
+
+        return dec
+
+    return fun
+
+
+@overload
+def wasm(arg: Callable[P, T]) -> GuppyFunctionDefinition[P, T]: ...
+
+
+@overload
+def wasm(arg: int) -> Callable[[Callable[P, T]], GuppyFunctionDefinition[P, T]]: ...
+
+
+def wasm(
+    arg: int | Callable[P, T],
+) -> (
+    GuppyFunctionDefinition[P, T]
+    | Callable[[Callable[P, T]], GuppyFunctionDefinition[P, T]]
+):
+    if isinstance(arg, int):
+
+        def wrapper(f: Callable[P, T]) -> GuppyFunctionDefinition[P, T]:
+            return wasm_helper(arg, f)
+
+        return wrapper
+    else:
+        return wasm_helper(None, arg)
+
+
+def wasm_helper(fn_id: int | None, f: Callable[P, T]) -> GuppyFunctionDefinition[P, T]:
     from guppylang.defs import GuppyFunctionDefinition
 
     func = RawWasmFunctionDef(
@@ -246,7 +312,7 @@ def wasm(f: Callable[P, T]) -> GuppyFunctionDefinition[P, T]:
         None,
         f,
         WasmCallChecker(),
-        WasmModuleCallCompiler(f.__name__),
+        WasmModuleCallCompiler(f.__name__, fn_id),
         True,
         signature=None,
     )

guppylang_internals/definition/const.py

@@ -15,7 +15,7 @@ from guppylang_internals.definition.value import (
     ValueDef,
 )
 from guppylang_internals.span import SourceMap
-from guppylang_internals.tys.parsing import type_from_ast
+from guppylang_internals.tys.parsing import TypeParsingCtx, type_from_ast
 
 
 @dataclass(frozen=True)
@@ -33,7 +33,7 @@ class RawConstDef(ParsableDef):
             self.id,
             self.name,
             self.defined_at,
-            type_from_ast(self.type_ast, globals, {}),
+            type_from_ast(self.type_ast, TypeParsingCtx(globals)),
             self.type_ast,
             self.value,
         )

guppylang_internals/definition/custom.py

@@ -7,6 +7,7 @@ from typing import TYPE_CHECKING, ClassVar
 from hugr import Wire, ops
 from hugr import tys as ht
 from hugr.build.dfg import DfBase
+from hugr.std.collections.borrow_array import EXTENSION as BORROW_ARRAY_EXTENSION
 
 from guppylang_internals.ast_util import (
     AstNode,
@@ -23,6 +24,7 @@ from guppylang_internals.compiler.core import (
     DFContainer,
     GlobalConstId,
     partially_monomorphize_args,
+    qualified_name,
 )
 from guppylang_internals.definition.common import ParsableDef
 from guppylang_internals.definition.value import CallReturnWires, CompiledCallableDef
@@ -169,7 +171,7 @@ class RawCustomFunctionDef(ParsableDef):
             raise GuppyError(NoSignatureError(node, self.name))
 
         if requires_type_annotation:
-            return check_signature(node, globals)
+            return check_signature(node, globals, self.id)
         else:
             return None
 
@@ -486,7 +488,39 @@ class NoopCompiler(CustomCallCompiler):
 
 
 class CopyInoutCompiler(CustomInoutCallCompiler):
-    """Call compiler for functions that are noops but only want to borrow arguments."""
+    """Call compiler for functions that borrow one argument to copy it."""
 
     def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        assert len(self.ty.input) == 1
+        inp_ty = self.ty.input[0]
+        if inp_ty.type_bound() == ht.TypeBound.Linear:
+            (arg,) = args
+            copies = self._handle_affine_type(inp_ty, arg)
+            return CallReturnWires(
+                regular_returns=[copies[0]], inout_returns=[copies[1]]
+            )
         return CallReturnWires(regular_returns=args, inout_returns=args)
+
+    # Affine types in Guppy backed by a linear Hugr type need to be copied explicitly.
+    # TODO: Handle affine extension types more generally (borrow arrays are currently
+    # the only case).
+    def _handle_affine_type(self, ty: ht.Type, arg: Wire) -> list[Wire]:
+        match ty:
+            case ht.ExtType(type_def=type_def, args=type_args):
+                if qualified_name(type_def) == qualified_name(
+                    BORROW_ARRAY_EXTENSION.get_type("borrow_array")
+                ):
+                    assert len(type_args) == 2
+                    # Manually instantiate here to avoid circular import and use
+                    # type args directly.
+                    clone_op = BORROW_ARRAY_EXTENSION.get_op("clone").instantiate(
+                        type_args,
+                        ht.FunctionType(self.ty.input, self.ty.output),
+                    )
+                    return list(self.builder.add_op(clone_op, arg))
+            case _:
+                pass
+        raise InternalGuppyError(
+            f"Type `{ty}` needs an explicit handler in the `copy` compiler as "
+            "it is an affine Guppy type backed by a linear Hugr type."
+        )

guppylang_internals/definition/declaration.py

@@ -13,7 +13,7 @@ from guppylang_internals.checker.func_checker import check_signature
 from guppylang_internals.compiler.core import (
     CompilerContext,
     DFContainer,
-    requires_monomorphization,
+    require_monomorphization,
 )
 from guppylang_internals.definition.common import CompilableDef, ParsableDef
 from guppylang_internals.definition.function import (
@@ -68,13 +68,12 @@ class RawFunctionDecl(ParsableDef):
     def parse(self, globals: Globals, sources: SourceMap) -> "CheckedFunctionDecl":
         """Parses and checks the user-provided signature of the function."""
         func_ast, docstring = parse_py_func(self.python_func, sources)
-        ty = check_signature(func_ast, globals)
+        ty = check_signature(func_ast, globals, self.id)
         if not has_empty_body(func_ast):
             raise GuppyError(BodyNotEmptyError(func_ast.body[0], self.name))
         # Make sure we won't need monomorphization to compile this declaration
-        for param in ty.params:
-            if requires_monomorphization(param):
-                raise GuppyError(MonomorphizeError(func_ast, self.name, param))
+        if mono_params := require_monomorphization(ty.params):
+            raise GuppyError(MonomorphizeError(func_ast, self.name, mono_params.pop()))
         return CheckedFunctionDecl(
             self.id,
             self.name,

guppylang_internals/definition/extern.py

@@ -14,7 +14,7 @@ from guppylang_internals.definition.value import (
     ValueDef,
 )
 from guppylang_internals.span import SourceMap
-from guppylang_internals.tys.parsing import type_from_ast
+from guppylang_internals.tys.parsing import TypeParsingCtx, type_from_ast
 
 
 @dataclass(frozen=True)
@@ -33,7 +33,7 @@ class RawExternDef(ParsableDef):
             self.id,
             self.name,
             self.defined_at,
-            type_from_ast(self.type_ast, globals, {}),
+            type_from_ast(self.type_ast, TypeParsingCtx(globals)),
             self.symbol,
             self.constant,
             self.type_ast,

guppylang_internals/definition/function.py

@@ -73,7 +73,7 @@ class RawFunctionDef(ParsableDef):
     def parse(self, globals: Globals, sources: SourceMap) -> "ParsedFunctionDef":
         """Parses and checks the user-provided signature of the function."""
         func_ast, docstring = parse_py_func(self.python_func, sources)
-        ty = check_signature(func_ast, globals)
+        ty = check_signature(func_ast, globals, self.id)
         return ParsedFunctionDef(self.id, self.name, func_ast, ty, docstring)
 
 

guppylang_internals/definition/parameter.py

@@ -38,14 +38,19 @@ class ParamDef(Definition):
 class TypeVarDef(ParamDef, CompiledDef):
     """A type variable definition."""
 
-    must_be_copyable: bool
-    must_be_droppable: bool
+    copyable: bool
+    droppable: bool
 
     description: str = field(default="type variable", init=False)
 
     def to_param(self, idx: int) -> TypeParam:
         """Creates a parameter from this definition."""
-        return TypeParam(idx, self.name, self.must_be_copyable, self.must_be_droppable)
+        return TypeParam(
+            idx,
+            self.name,
+            must_be_copyable=self.copyable,
+            must_be_droppable=self.droppable,
+        )
 
 
 @dataclass(frozen=True)
@@ -56,9 +61,9 @@ class RawConstVarDef(ParamDef, ParsableDef):
     description: str = field(default="const variable", init=False)
 
     def parse(self, globals: Globals, sources: SourceMap) -> "ConstVarDef":
-        from guppylang_internals.tys.parsing import type_from_ast
+        from guppylang_internals.tys.parsing import TypeParsingCtx, type_from_ast
 
-        ty = type_from_ast(self.type_ast, globals, {})
+        ty = type_from_ast(self.type_ast, TypeParsingCtx(globals))
         if not ty.copyable or not ty.droppable:
             raise GuppyError(LinearConstVarError(self.type_ast, self.name, ty))
         return ConstVarDef(self.id, self.name, self.defined_at, ty)