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

guppylang_internals/tracing/function.py

@@ -176,10 +176,21 @@ def trace_call(func: CallableDef, *args: Any) -> Any:
     if len(func.ty.inputs) != 0:
         for inp, arg, var in zip(func.ty.inputs, args, arg_vars, strict=True):
             if InputFlags.Inout in inp.flags:
+                # Note that `inp.ty` could refer to bound variables in the function
+                # signature. Instead, make sure to use `var.ty` which will always be a
+                # concrete type and type checking has ensured that they unify.
+                ty = var.ty
                 inout_wire = state.dfg[var]
-                update_packed_value(
-                    arg, GuppyObject(inp.ty, inout_wire), state.dfg.builder
+                success = update_packed_value(
+                    arg, GuppyObject(ty, inout_wire), state.dfg.builder
                 )
+                if not success:
+                    # This means the user has passed an object that we cannot update,
+                    # e.g. calling `mem_swap(x, y)` where the inputs are plain Python
+                    # objects
+                    raise GuppyComptimeError(
+                        f"Cannot borrow Python object of type `{ty}` at comptime"
+                    )
 
     ret_obj = GuppyObject(ret_ty, ret_wire)
     return unpack_guppy_object(ret_obj, state.dfg.builder)

guppylang_internals/tracing/unpacking.py

@@ -1,7 +1,6 @@
 from typing import Any, TypeVar
 
 from hugr import ops
-from hugr import tys as ht
 from hugr.build.dfg import DfBase
 
 from guppylang_internals.ast_util import AstNode
@@ -13,7 +12,6 @@ from guppylang_internals.compiler.core import CompilerContext
 from guppylang_internals.compiler.expr_compiler import python_value_to_hugr
 from guppylang_internals.error import GuppyComptimeError, GuppyError
 from guppylang_internals.std._internal.compiler.array import array_new, unpack_array
-from guppylang_internals.std._internal.compiler.prelude import build_unwrap
 from guppylang_internals.tracing.frozenlist import frozenlist
 from guppylang_internals.tracing.object import (
     GuppyObject,
@@ -71,9 +69,7 @@ def unpack_guppy_object(
                     # them as Guppy objects here
                     return obj
                 elem_ty = get_element_type(ty)
-                opt_elems = unpack_array(builder, obj._use_wire(None))
-                err = "Non-copyable array element has already been used"
-                elems = [build_unwrap(builder, opt_elem, err) for opt_elem in opt_elems]
+                elems = unpack_array(builder, obj._use_wire(None))
                 obj_list = [
                     unpack_guppy_object(GuppyObject(elem_ty, wire), builder, frozen)
                     for wire in elems
@@ -128,11 +124,8 @@ def guppy_object_from_py(
                         f"Element at index {i + 1} does not match the type of "
                         f"previous elements. Expected `{elem_ty}`, got `{obj._ty}`."
                     )
-            hugr_elem_ty = ht.Option(elem_ty.to_hugr(ctx))
-            wires = [
-                builder.add_op(ops.Tag(1, hugr_elem_ty), obj._use_wire(None))
-                for obj in objs
-            ]
+            hugr_elem_ty = elem_ty.to_hugr(ctx)
+            wires = [obj._use_wire(None) for obj in objs]
             return GuppyObject(
                 array_type(elem_ty, len(vs)),
                 builder.add_op(array_new(hugr_elem_ty, len(vs)), *wires),
@@ -150,13 +143,15 @@ def guppy_object_from_py(
             return GuppyObject(ty, builder.load(hugr_val))
 
 
-def update_packed_value(v: Any, obj: "GuppyObject", builder: DfBase[P]) -> None:
+def update_packed_value(v: Any, obj: "GuppyObject", builder: DfBase[P]) -> bool:
     """Given a Python value `v` and a `GuppyObject` `obj` that was constructed from `v`
-    using `guppy_object_from_py`, updates the wires of any `GuppyObjects` contained in
-    `v` to the new wires specified by `obj`.
+    using `guppy_object_from_py`, tries to update the wires of any `GuppyObjects`
+    contained in `v` to the new wires specified by `obj`.
 
     Also resets the used flag on any of those updated wires. This corresponds to making
     the object available again since it now corresponds to a fresh wire.
+
+    Returns `True` if all wires could be updated, otherwise `False`.
     """
     match v:
         case GuppyObject() as v_obj:
@@ -170,25 +165,35 @@ def update_packed_value(v: Any, obj: "GuppyObject", builder: DfBase[P]) -> None:
             assert isinstance(obj._ty, NoneType)
         case tuple(vs):
             assert isinstance(obj._ty, TupleType)
-            wires = builder.add_op(ops.UnpackTuple(), obj._use_wire(None)).outputs()
-            for v, ty, wire in zip(vs, obj._ty.element_types, wires, strict=True):
-                update_packed_value(v, GuppyObject(ty, wire), builder)
+            wire_iterator = builder.add_op(
+                ops.UnpackTuple(), obj._use_wire(None)
+            ).outputs()
+            for v, ty, out_wire in zip(
+                vs, obj._ty.element_types, wire_iterator, strict=True
+            ):
+                success = update_packed_value(v, GuppyObject(ty, out_wire), builder)
+                if not success:
+                    return False
         case GuppyStructObject(_ty=ty, _field_values=values):
             assert obj._ty == ty
-            wires = builder.add_op(ops.UnpackTuple(), obj._use_wire(None)).outputs()
-            for (
-                field,
-                wire,
-            ) in zip(ty.fields, wires, strict=True):
+            wire_iterator = builder.add_op(
+                ops.UnpackTuple(), obj._use_wire(None)
+            ).outputs()
+            for field, out_wire in zip(ty.fields, wire_iterator, strict=True):
                 v = values[field.name]
-                update_packed_value(v, GuppyObject(field.ty, wire), builder)
+                success = update_packed_value(
+                    v, GuppyObject(field.ty, out_wire), builder
+                )
+                if not success:
+                    values[field.name] = obj
         case list(vs) if len(vs) > 0:
             assert is_array_type(obj._ty)
             elem_ty = get_element_type(obj._ty)
-            opt_wires = unpack_array(builder, obj._use_wire(None))
-            err = "Non-droppable array element has already been used"
-            for v, opt_wire in zip(vs, opt_wires, strict=True):
-                (wire,) = build_unwrap(builder, opt_wire, err).outputs()
-                update_packed_value(v, GuppyObject(elem_ty, wire), builder)
+            wires = unpack_array(builder, obj._use_wire(None))
+            for i, (v, wire) in enumerate(zip(vs, wires, strict=True)):
+                success = update_packed_value(v, GuppyObject(elem_ty, wire), builder)
+                if not success:
+                    vs[i] = obj
         case _:
-            pass
+            return False
+    return True

guppylang_internals/tys/arg.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, TypeAlias
 
 from hugr import tys as ht
@@ -18,7 +18,7 @@ from guppylang_internals.tys.const import (
     ConstValue,
     ExistentialConstVar,
 )
-from guppylang_internals.tys.var import ExistentialVar
+from guppylang_internals.tys.var import BoundVar, ExistentialVar
 
 if TYPE_CHECKING:
     from guppylang_internals.tys.ty import Type
@@ -45,19 +45,29 @@ class ArgumentBase(ToHugr[ht.TypeArg], Transformable["Argument"], ABC):
     def unsolved_vars(self) -> set[ExistentialVar]:
         """The existential type variables contained in this argument."""
 
+    @property
+    @abstractmethod
+    def bound_vars(self) -> set[BoundVar]:
+        """The bound type variables contained in this argument."""
+
 
 @dataclass(frozen=True)
 class TypeArg(ArgumentBase):
     """Argument that can be instantiated for a `TypeParameter`."""
 
     # The type to instantiate
-    ty: "Type"
+    ty: "Type" = field(hash=False)  # Types are not hashable
 
     @property
     def unsolved_vars(self) -> set[ExistentialVar]:
         """The existential type variables contained in this argument."""
         return self.ty.unsolved_vars
 
+    @property
+    def bound_vars(self) -> set[BoundVar]:
+        """The bound type variables contained in this type."""
+        return self.ty.bound_vars
+
     def to_hugr(self, ctx: ToHugrContext) -> ht.TypeTypeArg:
         """Computes the Hugr representation of the argument."""
         ty: ht.Type = self.ty.to_hugr(ctx)
@@ -84,6 +94,11 @@ class ConstArg(ArgumentBase):
         """The existential const variables contained in this argument."""
         return self.const.unsolved_vars
 
+    @property
+    def bound_vars(self) -> set[BoundVar]:
+        """The bound type variables contained in this argument."""
+        return self.const.bound_vars
+
     def to_hugr(self, ctx: ToHugrContext) -> ht.TypeArg:
         """Computes the Hugr representation of this argument."""
         from guppylang_internals.tys.ty import NumericType

guppylang_internals/tys/builtin.py

@@ -46,6 +46,27 @@ class CallableTypeDef(TypeDef, CompiledDef):
         raise InternalGuppyError("Tried to `Callable` type via `check_instantiate`")
 
 
+@dataclass(frozen=True)
+class SelfTypeDef(TypeDef, CompiledDef):
+    """Type definition associated with the `Self` type on methods.
+
+    During type parsing, we make sure that this type is replaced with the concrete type
+    the method is attached to. Thus, we should never have instances of this type around.
+
+    In other words, this definition is only a marker so that type parsing doesn't have
+    to rely on matching against the string "Self". By making `Self` a definition, we can
+    use the existing identifier tracking system and also handle users shadowing the
+    `Self` binder or assigning `Self` to some other name.
+    """
+
+    name: Literal["Self"] = field(default="Self", init=False)
+
+    def check_instantiate(
+        self, args: Sequence[Argument], loc: AstNode | None = None
+    ) -> FunctionType:
+        raise InternalGuppyError("Tried to instantiate abstract `Self` type`")
+
+
 @dataclass(frozen=True)
 class _TupleTypeDef(TypeDef, CompiledDef):
     """Type definition associated with the builtin `tuple` type.
@@ -106,7 +127,6 @@ class _NumericTypeDef(TypeDef, CompiledDef):
 
 class WasmModuleTypeDef(OpaqueTypeDef):
     wasm_file: str
-    wasm_hash: int
 
     def __init__(
         self,
@@ -114,11 +134,9 @@ class WasmModuleTypeDef(OpaqueTypeDef):
         name: str,
         defined_at: ast.AST | None,
         wasm_file: str,
-        wasm_hash: int,
     ) -> None:
         super().__init__(id, name, defined_at, [], True, True, self.to_hugr)
         self.wasm_file = wasm_file
-        self.wasm_hash = wasm_hash
 
     def to_hugr(
         self, args: Sequence[TypeArg | ConstArg], ctx: ToHugrContext
@@ -159,13 +177,10 @@ def _array_to_hugr(args: Sequence[Argument], ctx: ToHugrContext) -> ht.Type:
     assert isinstance(ty_arg, TypeArg)
     assert isinstance(len_arg, ConstArg)
 
-    # Linear elements are turned into an optional to enable unsafe indexing.
-    # See `ArrayGetitemCompiler` for details.
-    # Same also for classical arrays, see https://github.com/CQCL/guppylang/issues/629
-    elem_ty = ht.Option(ty_arg.ty.to_hugr(ctx))
+    elem_ty = ty_arg.ty.to_hugr(ctx)
     hugr_arg = len_arg.to_hugr(ctx)
 
-    return hugr.std.collections.value_array.ValueArray(elem_ty, hugr_arg)
+    return hugr.std.collections.borrow_array.BorrowArray(elem_ty, hugr_arg)
 
 
 def _frozenarray_to_hugr(args: Sequence[Argument], ctx: ToHugrContext) -> ht.Type:
@@ -189,9 +204,10 @@ def _option_to_hugr(args: Sequence[Argument], ctx: ToHugrContext) -> ht.Type:
     return ht.Option(arg.ty.to_hugr(ctx))
 
 
-callable_type_def = CallableTypeDef(DefId.fresh(), None)
-tuple_type_def = _TupleTypeDef(DefId.fresh(), None)
-none_type_def = _NoneTypeDef(DefId.fresh(), None)
+callable_type_def = CallableTypeDef(DefId.fresh(), None, None)
+self_type_def = SelfTypeDef(DefId.fresh(), None, [])
+tuple_type_def = _TupleTypeDef(DefId.fresh(), None, None)
+none_type_def = _NoneTypeDef(DefId.fresh(), None, [])
 bool_type_def = OpaqueTypeDef(
     id=DefId.fresh(),
     name="bool",
@@ -202,13 +218,13 @@ bool_type_def = OpaqueTypeDef(
     to_hugr=lambda args, ctx: OpaqueBool,
 )
 nat_type_def = _NumericTypeDef(
-    DefId.fresh(), "nat", None, NumericType(NumericType.Kind.Nat)
+    DefId.fresh(), "nat", None, [], NumericType(NumericType.Kind.Nat)
 )
 int_type_def = _NumericTypeDef(
-    DefId.fresh(), "int", None, NumericType(NumericType.Kind.Int)
+    DefId.fresh(), "int", None, [], NumericType(NumericType.Kind.Int)
 )
 float_type_def = _NumericTypeDef(
-    DefId.fresh(), "float", None, NumericType(NumericType.Kind.Float)
+    DefId.fresh(), "float", None, [], NumericType(NumericType.Kind.Float)
 )
 string_type_def = OpaqueTypeDef(
     id=DefId.fresh(),
@@ -345,9 +361,9 @@ def is_sized_iter_type(ty: Type) -> TypeGuard[OpaqueType]:
     return isinstance(ty, OpaqueType) and ty.defn == sized_iter_type_def
 
 
-def wasm_module_info(ty: Type) -> tuple[str, int] | None:
+def wasm_module_name(ty: Type) -> str | None:
     if isinstance(ty, OpaqueType) and isinstance(ty.defn, WasmModuleTypeDef):
-        return ty.defn.wasm_file, ty.defn.wasm_hash
+        return ty.defn.wasm_file
     return None
 
 

guppylang_internals/tys/const.py

@@ -8,6 +8,7 @@ from guppylang_internals.tys.var import BoundVar, ExistentialVar
 
 if TYPE_CHECKING:
     from guppylang_internals.tys.arg import ConstArg
+    from guppylang_internals.tys.subst import Subst
     from guppylang_internals.tys.ty import Type
 
 
@@ -39,6 +40,11 @@ class ConstBase(Transformable["Const"], ABC):
         """The existential type variables contained in this constant."""
         return set()
 
+    @property
+    def bound_vars(self) -> set[BoundVar]:
+        """The bound type variables contained in this constant."""
+        return self.ty.bound_vars
+
     def __str__(self) -> str:
         from guppylang_internals.tys.printing import TypePrinter
 
@@ -48,16 +54,18 @@ class ConstBase(Transformable["Const"], ABC):
         """Accepts a visitor on this constant."""
         visitor.visit(self)
 
-    def transform(self, transformer: Transformer, /) -> "Const":
-        """Accepts a transformer on this constant."""
-        return transformer.transform(self) or self.cast()
-
     def to_arg(self) -> "ConstArg":
         """Wraps this constant into a type argument."""
         from guppylang_internals.tys.arg import ConstArg
 
         return ConstArg(self.cast())
 
+    def substitute(self, subst: "Subst") -> "Const":
+        """Substitutes existential variables in this constant."""
+        from guppylang_internals.tys.subst import Substituter
+
+        return self.transform(Substituter(subst))
+
 
 @dataclass(frozen=True)
 class ConstValue(ConstBase):
@@ -74,6 +82,10 @@ class ConstValue(ConstBase):
         """Casts an implementor of `ConstBase` into a `Const`."""
         return self
 
+    def transform(self, transformer: Transformer, /) -> "Const":
+        """Accepts a transformer on this constant."""
+        return transformer.transform(self) or self
+
 
 @dataclass(frozen=True)
 class BoundConstVar(BoundVar, ConstBase):
@@ -84,10 +96,21 @@ class BoundConstVar(BoundVar, ConstBase):
     `BoundConstVar(idx=0)`.
     """
 
+    @property
+    def bound_vars(self) -> set[BoundVar]:
+        """The bound type variables contained in this constant."""
+        return {self} | self.ty.bound_vars
+
     def cast(self) -> "Const":
         """Casts an implementor of `ConstBase` into a `Const`."""
         return self
 
+    def transform(self, transformer: Transformer, /) -> "Const":
+        """Accepts a transformer on this constant."""
+        return transformer.transform(self) or BoundConstVar(
+            transformer.transform(self.ty) or self.ty, self.display_name, self.idx
+        )
+
 
 @dataclass(frozen=True)
 class ExistentialConstVar(ExistentialVar, ConstBase):
@@ -110,5 +133,11 @@ class ExistentialConstVar(ExistentialVar, ConstBase):
         """Casts an implementor of `ConstBase` into a `Const`."""
         return self
 
+    def transform(self, transformer: Transformer, /) -> "Const":
+        """Accepts a transformer on this constant."""
+        return transformer.transform(self) or ExistentialConstVar(
+            transformer.transform(self.ty) or self.ty, self.display_name, self.id
+        )
+
 
 Const: TypeAlias = ConstValue | BoundConstVar | ExistentialConstVar

guppylang_internals/tys/errors.py

@@ -116,6 +116,12 @@ class InvalidCallableTypeError(Error):
         self.add_sub_diagnostic(InvalidCallableTypeError.Explain(None))
 
 
+@dataclass(frozen=True)
+class SelfTyNotInMethodError(Error):
+    title: ClassVar[str] = "Invalid type"
+    span_label: ClassVar[str] = "`Self` type annotations are only allowed in methods"
+
+
 @dataclass(frozen=True)
 class NonLinearOwnedError(Error):
     title: ClassVar[str] = "Invalid annotation"

guppylang_internals/tys/param.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from typing import TYPE_CHECKING, TypeAlias
 
 from hugr import tys as ht
@@ -17,9 +17,9 @@ from guppylang_internals.tys.errors import WrongNumberOfTypeArgsError
 from guppylang_internals.tys.var import ExistentialVar
 
 if TYPE_CHECKING:
+    from guppylang_internals.tys.subst import PartialInst
     from guppylang_internals.tys.ty import Type
 
-
 # We define the `Parameter` type as a union of all `ParameterBase` subclasses defined
 # below. This models an algebraic data type and enables exhaustiveness checking in
 # pattern matches etc.
@@ -74,6 +74,10 @@ class ParameterBase(ToHugr[ht.TypeParam], ABC):
         parameter.
         """
 
+    @abstractmethod
+    def instantiate_bounds(self, inst: "PartialInst") -> Self:
+        """Instantiates bound variables mentioned in parameter bounds"""
+
 
 @dataclass(frozen=True)
 class TypeParam(ParameterBase):
@@ -142,10 +146,17 @@ class TypeParam(ParameterBase):
             BoundTypeVar(self.name, idx, self.must_be_copyable, self.must_be_droppable)
         )
 
+    def instantiate_bounds(self, inst: "PartialInst") -> "TypeParam":
+        """Instantiates bound variables mentioned in parameter bounds"""
+        # For now, type parameters don't have any bounds that could be instantiated
+        return self
+
     def to_hugr(self, ctx: ToHugrContext) -> ht.TypeParam:
         """Computes the Hugr representation of the parameter."""
         return ht.TypeTypeParam(
-            bound=ht.TypeBound.Linear if self.can_be_linear else ht.TypeBound.Copyable
+            bound=ht.TypeBound.Copyable
+            if self.must_be_copyable
+            else ht.TypeBound.Linear
         )
 
     def __str__(self) -> str:
@@ -157,18 +168,12 @@ class TypeParam(ParameterBase):
 class ConstParam(ParameterBase):
     """A parameter of kind constant. Used to define fixed-size arrays etc."""
 
-    ty: "Type"
+    ty: "Type" = field(hash=False)
 
     #: Marker to annotate if this parameter was implicitly generated by a `@comptime`
     #: annotated argument in a function signature.
     from_comptime_arg: bool = field(default=False, kw_only=True)
 
-    def __post_init__(self) -> None:
-        if self.ty.unsolved_vars:
-            raise InternalGuppyError(
-                "Attempted to create constant param with unsolved type"
-            )
-
     def with_idx(self, idx: int) -> "ConstParam":
         """Returns a copy of the parameter with a new index."""
         return ConstParam(idx, self.name, self.ty)
@@ -178,13 +183,16 @@ class ConstParam(ParameterBase):
 
         Raises a user error if the argument is not valid.
         """
+        from guppylang_internals.tys.ty import unify
+
         match arg:
             case ConstArg(const):
-                if const.ty != self.ty:
+                subst = unify(const.ty, self.ty, {})
+                if subst is None:
                     raise GuppyTypeError(
                         TypeMismatchError(loc, self.ty, const.ty, kind="argument")
                     )
-                return arg
+                return ConstArg(replace(const, ty=const.ty.substitute(subst)))
             case TypeArg(ty=ty):
                 err = ExpectedError(
                     loc, f"expression of type `{self.ty}`", got=f"type `{ty}`"
@@ -208,6 +216,13 @@ class ConstParam(ParameterBase):
             idx = self.idx
         return ConstArg(BoundConstVar(self.ty, self.name, idx))
 
+    def instantiate_bounds(self, inst: "PartialInst") -> "ConstParam":
+        """Instantiates bound variables mentioned in parameter bounds"""
+        from guppylang_internals.tys.subst import Instantiator
+
+        instantiator = Instantiator(inst)
+        return replace(self, ty=self.ty.transform(instantiator))
+
     def to_hugr(self, ctx: ToHugrContext) -> ht.TypeParam:
         """Computes the Hugr representation of the parameter."""
         from guppylang_internals.tys.ty import NumericType
@@ -231,6 +246,7 @@ def check_all_args(
     args: Sequence[Argument],
     type_name: str,
     loc: AstNode | None = None,
+    arg_locs: Sequence[AstNode] | None = None,
 ) -> None:
     """Checks a list of arguments against the given parameters.
 
@@ -245,7 +261,6 @@ def check_all_args(
         raise GuppyError(WrongNumberOfTypeArgsError(loc, exp, act, type_name))
 
     # Now check that the kinds match up
-    for param, arg in zip(params, args, strict=True):
-        # TODO: The error location is bad. We want the location of `arg`, not of the
-        #  whole thing.
-        param.check_arg(arg, loc)
+    for i, (param, arg) in enumerate(zip(params, args, strict=True)):
+        arg_loc = arg_locs[i] if arg_locs else loc
+        param.instantiate_bounds(args).check_arg(arg, arg_loc)