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

guppylang_internals/definition/struct.py

@@ -3,7 +3,7 @@ import inspect
 import linecache
 import sys
 from collections.abc import Sequence
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from types import FrameType
 from typing import ClassVar
 
@@ -39,7 +39,7 @@ from guppylang_internals.ipython_inspect import is_running_ipython
 from guppylang_internals.span import SourceMap, Span, to_span
 from guppylang_internals.tys.arg import Argument
 from guppylang_internals.tys.param import Parameter, check_all_args
-from guppylang_internals.tys.parsing import type_from_ast
+from guppylang_internals.tys.parsing import TypeParsingCtx, type_from_ast
 from guppylang_internals.tys.ty import (
     FuncInput,
     FunctionType,
@@ -115,6 +115,7 @@ class RawStructDef(TypeDef, ParsableDef):
     """A raw struct type definition that has not been parsed yet."""
 
     python_class: type
+    params: None = field(default=None, init=False)  # Params not known yet
 
     def parse(self, globals: Globals, sources: SourceMap) -> "ParsedStructDef":
         """Parses the raw class object into an AST and checks that it is well-formed."""
@@ -211,15 +212,16 @@ class ParsedStructDef(TypeDef, CheckableDef):
 
     def check(self, globals: Globals) -> "CheckedStructDef":
         """Checks that all struct fields have valid types."""
+        param_var_mapping = {p.name: p for p in self.params}
+        ctx = TypeParsingCtx(globals, param_var_mapping)
+
         # Before checking the fields, make sure that this definition is not recursive,
         # otherwise the code below would not terminate.
         # TODO: This is not ideal (see todo in `check_instantiate`)
-        param_var_mapping = {p.name: p for p in self.params}
-        check_not_recursive(self, globals, param_var_mapping)
+        check_not_recursive(self, ctx)
 
         fields = [
-            StructField(f.name, type_from_ast(f.type_ast, globals, param_var_mapping))
-            for f in self.fields
+            StructField(f.name, type_from_ast(f.type_ast, ctx)) for f in self.fields
         ]
         return CheckedStructDef(
             self.id, self.name, self.defined_at, self.params, fields
@@ -370,9 +372,7 @@ def params_from_ast(nodes: Sequence[ast.expr], globals: Globals) -> list[Paramet
     return params
 
 
-def check_not_recursive(
-    defn: ParsedStructDef, globals: Globals, param_var_mapping: dict[str, Parameter]
-) -> None:
+def check_not_recursive(defn: ParsedStructDef, ctx: TypeParsingCtx) -> None:
     """Throws a user error if the given struct definition is recursive."""
 
     # TODO: The implementation below hijacks the type parsing logic to detect recursive
@@ -388,5 +388,5 @@ def check_not_recursive(
     original = defn.check_instantiate
     object.__setattr__(defn, "check_instantiate", dummy_check_instantiate)
     for fld in defn.fields:
-        type_from_ast(fld.type_ast, globals, param_var_mapping)
+        type_from_ast(fld.type_ast, ctx)
     object.__setattr__(defn, "check_instantiate", original)

guppylang_internals/definition/traced.py

@@ -48,7 +48,7 @@ class RawTracedFunctionDef(ParsableDef):
     def parse(self, globals: Globals, sources: SourceMap) -> "TracedFunctionDef":
         """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 ty.parametrized:
             raise GuppyError(UnsupportedError(func_ast, "Generic comptime functions"))
         return TracedFunctionDef(self.id, self.name, func_ast, ty, self.python_func)

guppylang_internals/definition/ty.py

@@ -18,6 +18,12 @@ class TypeDef(Definition):
 
     description: str = field(default="type", init=False)
 
+    #: Generic parameters of the type. This may be `None` for special types that are
+    #: more polymorphic than the regular type system allows (for example `tuple` and
+    #: `Callable`), or if this is a raw definition whose parameters are not determined
+    #: yet (for example a `RawStructDef`).
+    params: Sequence[Parameter] | None
+
     @abstractmethod
     def check_instantiate(
         self, args: Sequence[Argument], loc: AstNode | None = None

guppylang_internals/definition/wasm.py

@@ -11,7 +11,7 @@ from guppylang_internals.definition.custom import (
 )
 from guppylang_internals.error import GuppyError
 from guppylang_internals.span import SourceMap
-from guppylang_internals.tys.builtin import wasm_module_info
+from guppylang_internals.tys.builtin import wasm_module_name
 from guppylang_internals.tys.ty import (
     FuncInput,
     FunctionType,
@@ -30,7 +30,7 @@ class RawWasmFunctionDef(RawCustomFunctionDef):
     def sanitise_type(self, loc: AstNode | None, fun_ty: FunctionType) -> None:
         # Place to highlight in error messages
         match fun_ty.inputs[0]:
-            case FuncInput(ty=ty, flags=InputFlags.Inout) if wasm_module_info(
+            case FuncInput(ty=ty, flags=InputFlags.Inout) if wasm_module_name(
                 ty
             ) is not None:
                 pass

guppylang_internals/engine.py

@@ -41,6 +41,7 @@ from guppylang_internals.tys.builtin import (
     nat_type_def,
     none_type_def,
     option_type_def,
+    self_type_def,
     sized_iter_type_def,
     string_type_def,
     tuple_type_def,
@@ -51,6 +52,7 @@ if TYPE_CHECKING:
 
 BUILTIN_DEFS_LIST: list[RawDef] = [
     callable_type_def,
+    self_type_def,
     tuple_type_def,
     none_type_def,
     bool_type_def,
@@ -84,12 +86,14 @@ class DefinitionStore:
 
     raw_defs: dict[DefId, RawDef]
     impls: defaultdict[DefId, dict[str, DefId]]
+    impl_parents: dict[DefId, DefId]
     frames: dict[DefId, FrameType]
     sources: SourceMap
 
     def __init__(self) -> None:
         self.raw_defs = {defn.id: defn for defn in BUILTIN_DEFS_LIST}
         self.impls = defaultdict(dict)
+        self.impl_parents = {}
         self.frames = {}
         self.sources = SourceMap()
 
@@ -99,7 +103,9 @@ class DefinitionStore:
             self.frames[defn.id] = frame
 
     def register_impl(self, ty_id: DefId, name: str, impl_id: DefId) -> None:
+        assert impl_id not in self.impl_parents, "Already an impl"
         self.impls[ty_id][name] = impl_id
+        self.impl_parents[impl_id] = ty_id
         # Update the frame of the definition to the frame of the defining class
         if impl_id in self.frames:
             frame = self.frames[impl_id].f_back
@@ -138,18 +144,23 @@ class CompilationEngine:
     types_to_check_worklist: dict[DefId, ParsedDef]
     to_check_worklist: dict[DefId, ParsedDef]
 
+    def __init__(self) -> None:
+        """Resets the compilation cache."""
+        self.reset()
+        self.additional_extensions = []
+
     def reset(self) -> None:
         """Resets the compilation cache."""
         self.parsed = {}
         self.checked = {}
         self.compiled = {}
-        self.additional_extensions = []
         self.to_check_worklist = {}
         self.types_to_check_worklist = {}
 
     @pretty_errors
     def register_extension(self, extension: Extension) -> None:
-        self.additional_extensions.append(extension)
+        if extension not in self.additional_extensions:
+            self.additional_extensions.append(extension)
 
     @pretty_errors
     def get_parsed(self, id: DefId) -> ParsedDef:

guppylang_internals/nodes.py

@@ -166,17 +166,6 @@ class MakeIter(ast.expr):
         self.unwrap_size_hint = unwrap_size_hint
 
 
-class IterHasNext(ast.expr):
-    """Checks if an iterator has a next element using the `__hasnext__` magic method.
-
-    This node is inserted in `for` loops and list comprehensions.
-    """
-
-    value: ast.expr
-
-    _fields = ("value",)
-
-
 class IterNext(ast.expr):
     """Obtains the next element of an iterator using the `__next__` magic method.
 
@@ -188,18 +177,6 @@ class IterNext(ast.expr):
     _fields = ("value",)
 
 
-class IterEnd(ast.expr):
-    """Finalises an iterator using the `__end__` magic method.
-
-    This node is inserted in `for` loops and list comprehensions. It is needed to
-    consume linear iterators once they are finished.
-    """
-
-    value: ast.expr
-
-    _fields = ("value",)
-
-
 class DesugaredGenerator(ast.expr):
     """A single desugared generator in a list comprehension.
 

guppylang_internals/std/_internal/compiler/tket_exts.py

@@ -47,16 +47,13 @@ class ConstWasmModule(val.ExtensionValue):
     """Python wrapper for the tket ConstWasmModule type"""
 
     wasm_file: str
-    wasm_hash: int
 
     def to_value(self) -> val.Extension:
         ty = WASM_EXTENSION.get_type("module").instantiate([])
 
-        name = "tket.wasm.ConstWasmModule"
-        payload = {"name": self.wasm_file, "hash": self.wasm_hash}
+        name = "ConstWasmModule"
+        payload = {"module_filename": self.wasm_file}
         return val.Extension(name, typ=ty, val=payload, extensions=["tket.wasm"])
 
     def __str__(self) -> str:
-        return (
-            f"ConstWasmModule(wasm_file={self.wasm_file}, wasm_hash={self.wasm_hash})"
-        )
+        return f"tket.wasm.module(module_filename={self.wasm_file})"

guppylang_internals/std/_internal/compiler/wasm.py

@@ -8,12 +8,11 @@ from guppylang_internals.nodes import GlobalCall
 from guppylang_internals.std._internal.compiler.arithmetic import convert_itousize
 from guppylang_internals.std._internal.compiler.prelude import build_unwrap
 from guppylang_internals.std._internal.compiler.tket_exts import (
-    FUTURES_EXTENSION,
     WASM_EXTENSION,
     ConstWasmModule,
 )
 from guppylang_internals.tys.builtin import (
-    wasm_module_info,
+    wasm_module_name,
 )
 from guppylang_internals.tys.ty import (
     FunctionType,
@@ -57,18 +56,20 @@ class WasmModuleDiscardCompiler(CustomInoutCallCompiler):
 
 class WasmModuleCallCompiler(CustomInoutCallCompiler):
     """Compiler for WASM calls
-    When a wasm method is called in guppy, we turn it into 2 tket ops:
+    When a wasm method is called in guppy, we turn it into 3 tket ops:
     * lookup: wasm.module -> wasm.func
-    * call: wasm.context * wasm.func * inputs -> wasm.context * output
-
+    * call: wasm.context * wasm.func * inputs -> wasm.result
+    * read_result: wasm.result -> wasm.context * outputs
     For the wasm.module that we use in lookup, a constant is created for each
     call, using the wasm file information embedded in method's `self` argument.
     """
 
     fn_name: str
+    fn_id: int | None
 
-    def __init__(self, name: str) -> None:
+    def __init__(self, name: str, id_: int | None) -> None:
         self.fn_name = name
+        self.fn_id = id_
 
     def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
         # The arguments should be:
@@ -93,14 +94,13 @@ class WasmModuleCallCompiler(CustomInoutCallCompiler):
         func_ty = WASM_EXTENSION.get_type("func").instantiate(
             [inputs_row_arg, output_row_arg]
         )
-        future_ty = FUTURES_EXTENSION.get_type("Future").instantiate(
-            [ht.Tuple(*wasm_sig.output).type_arg()]
-        )
+        result_ty = WASM_EXTENSION.get_type("result").instantiate([output_row_arg])
 
         # Get the WASM module information from the type
         selfarg = self.func.ty.inputs[0].ty
-        if info := wasm_module_info(selfarg):
-            const_module = self.builder.add_const(ConstWasmModule(*info))
+        info = wasm_module_name(selfarg)
+        if info is not None:
+            const_module = self.builder.add_const(ConstWasmModule(info))
         else:
             raise InternalGuppyError(
                 "Expected cached signature to have WASM module as first arg"
@@ -109,27 +109,38 @@ class WasmModuleCallCompiler(CustomInoutCallCompiler):
         wasm_module = self.builder.load(const_module)
 
         # Lookup the function we want
-        wasm_opdef = WASM_EXTENSION.get_op("lookup").instantiate(
-            [fn_name_arg, inputs_row_arg, output_row_arg],
-            ht.FunctionType([module_ty], [func_ty]),
-        )
+        if self.fn_id is None:
+            fn_name_arg = ht.StringArg(self.fn_name)
+            wasm_opdef = WASM_EXTENSION.get_op("lookup_by_name").instantiate(
+                [fn_name_arg, inputs_row_arg, output_row_arg],
+                ht.FunctionType([module_ty], [func_ty]),
+            )
+        else:
+            fn_id_arg = ht.BoundedNatArg(self.fn_id)
+            wasm_opdef = WASM_EXTENSION.get_op("lookup_by_id").instantiate(
+                [fn_id_arg, inputs_row_arg, output_row_arg],
+                ht.FunctionType([module_ty], [func_ty]),
+            )
+
         wasm_func = self.builder.add_op(wasm_opdef, wasm_module)
 
         # Call the function
         call_op = WASM_EXTENSION.get_op("call").instantiate(
             [inputs_row_arg, output_row_arg],
-            ht.FunctionType([ctx_ty, func_ty, *wasm_sig.input], [ctx_ty, future_ty]),
+            ht.FunctionType([ctx_ty, func_ty, *wasm_sig.input], [result_ty]),
         )
 
-        ctx, future = self.builder.add_op(call_op, args[0], wasm_func, *args[1:])
+        result = self.builder.add_op(call_op, args[0], wasm_func, *args[1:])
 
-        read_opdef = FUTURES_EXTENSION.get_op("Read").instantiate(
-            [ht.Tuple(*wasm_sig.output).type_arg()],
-            ht.FunctionType([future_ty], [ht.Tuple(*wasm_sig.output)]),
+        read_opdef = WASM_EXTENSION.get_op("read_result").instantiate(
+            [output_row_arg],
+            ht.FunctionType([result_ty], [ctx_ty, *wasm_sig.output]),
         )
-        result = self.builder.add_op(read_opdef, future)
-        ws: list[Wire] = list(result[:])
-        node = self.builder.add_op(ops.UnpackTuple(wasm_sig.output), *ws)
-        ws: list[Wire] = list(node[:])
-
-        return CallReturnWires(regular_returns=ws, inout_returns=[ctx])
+        data = self.builder.add_op(read_opdef, result)
+        match list(data[:]):
+            case [ctx]:
+                return CallReturnWires(regular_returns=[], inout_returns=[ctx])
+            case [ctx, *values]:
+                return CallReturnWires(regular_returns=[*values], inout_returns=[ctx])
+            case _:
+                raise AssertionError("impossible")

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

@@ -150,13 +150,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:
@@ -172,23 +174,27 @@ def update_packed_value(v: Any, obj: "GuppyObject", builder: DfBase[P]) -> None:
             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)
+                success = update_packed_value(v, GuppyObject(ty, 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):
+            for field, wire in zip(ty.fields, wires, strict=True):
                 v = values[field.name]
-                update_packed_value(v, GuppyObject(field.ty, wire), builder)
+                success = update_packed_value(v, GuppyObject(field.ty, 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):
+            for i, (v, opt_wire) in enumerate(zip(vs, opt_wires, strict=True)):
                 (wire,) = build_unwrap(builder, opt_wire, err).outputs()
-                update_packed_value(v, GuppyObject(elem_ty, wire), builder)
+                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/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
@@ -189,9 +207,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 +221,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 +364,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/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"