feat: Declare WASM modules in guppy

examples/random_walk_qpe.py

@@ -21,7 +21,9 @@
 @guppy
 def random_walk_phase_estimation(
     eigenstate: Callable[[], qubit],
-    controlled_oracle: Callable[[qubit @owned, qubit @owned, float], tuple[qubit, qubit]],
+    controlled_oracle: Callable[
+        [qubit @ owned, qubit @ owned, float], tuple[qubit, qubit]
+    ],
     num_iters: int,
     reset_rate: int,
     mu: float,
@@ -62,7 +64,9 @@ def random_walk_phase_estimation(
 
 
 @guppy
-def example_controlled_oracle(q1: qubit @owned, q2: qubit @owned, t: float) -> tuple[qubit, qubit]:
+def example_controlled_oracle(
+    q1: qubit @ owned, q2: qubit @ owned, t: float
+) -> tuple[qubit, qubit]:
     """A controlled e^itH gate for the example Hamiltonian H = -0.5 * Z"""
     # This is just a controlled rz gate
     a = angle(-0.5 * t)

guppylang/checker/errors/wasm.py

@@ -0,0 +1,34 @@
+from dataclasses import dataclass
+from typing import ClassVar
+
+from guppylang.diagnostic import Error
+from guppylang.tys.ty import Type
+
+
+@dataclass(frozen=True)
+class WasmError(Error):
+    title: ClassVar[str] = "WASM signature error"
+
+
+@dataclass(frozen=True)
+class FirstArgNotModule(WasmError):
+    span_label: ClassVar[str] = (
+        "First argument to WASM function should be a reference to a WASM module."
+        " Found `{ty}` instead"
+    )
+    ty: Type
+
+
+@dataclass(frozen=True)
+class UnWasmableType(WasmError):
+    span_label: ClassVar[str] = (
+        "WASM function signature contained an unsupported type: `{ty}`"
+    )
+    ty: Type
+
+
+@dataclass(frozen=True)
+class WasmTypeConversionError(Error):
+    title: ClassVar[str] = "Can't convert type to WASM"
+    span_label: ClassVar[str] = "`{thing}` cannot be converted to WASM"
+    ty: Type

guppylang/decorator.py

@@ -14,10 +14,12 @@
 from typing_extensions import dataclass_transform
 
 from guppylang.ast_util import annotate_location
+from guppylang.compiler.core import GlobalConstId
 from guppylang.definition.common import DefId
 from guppylang.definition.const import RawConstDef
 from guppylang.definition.custom import (
     CustomCallChecker,
+    CustomFunctionDef,
     CustomInoutCallCompiler,
     DefaultCallChecker,
     NotImplementedCallCompiler,
@@ -28,6 +30,7 @@
 from guppylang.definition.extern import RawExternDef
 from guppylang.definition.function import (
     CompiledFunctionDef,
+    PyFunc,
     RawFunctionDef,
 )
 from guppylang.definition.overloaded import OverloadedFunctionDef
@@ -40,14 +43,30 @@
 from guppylang.definition.struct import RawStructDef
 from guppylang.definition.traced import RawTracedFunctionDef
 from guppylang.definition.ty import OpaqueTypeDef, TypeDef
+from guppylang.definition.wasm import RawWasmFunctionDef
 from guppylang.dummy_decorator import _DummyGuppy, sphinx_running
 from guppylang.engine import DEF_STORE
 from guppylang.span import Loc, SourceMap, Span
+from guppylang.std._internal.checker import WasmCallChecker
+from guppylang.std._internal.compiler.wasm import (
+    WasmModuleCallCompiler,
+    WasmModuleDiscardCompiler,
+    WasmModuleInitCompiler,
+)
 from guppylang.tracing.object import GuppyDefinition, TypeVarGuppyDefinition
 from guppylang.tys.arg import Argument
+from guppylang.tys.builtin import (
+    WasmModuleTypeDef,
+)
 from guppylang.tys.param import Parameter
 from guppylang.tys.subst import Inst
-from guppylang.tys.ty import FunctionType, NoneType, NumericType
+from guppylang.tys.ty import (
+    FuncInput,
+    FunctionType,
+    InputFlags,
+    NoneType,
+    NumericType,
+)
 
 S = TypeVar("S")
 T = TypeVar("T")
@@ -420,6 +439,78 @@ def load_pytket(
         DEF_STORE.register_def(defn, get_calling_frame())
         return GuppyDefinition(defn)
 
+    def wasm_module(
+        self, filename: str, filehash: int
+    ) -> Decorator[builtins.type[T], 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)
+
+            return GuppyDefinition(wasm_module)
+
+        return dec
+
+    def wasm(self, f: PyFunc) -> GuppyDefinition:
+        func = RawWasmFunctionDef(
+            DefId.fresh(),
+            f.__name__,
+            None,
+            f,
+            WasmCallChecker(),
+            WasmModuleCallCompiler(f.__name__),
+            True,
+            signature=None,
+        )
+        DEF_STORE.register_def(func, get_calling_frame())
+        return GuppyDefinition(func)
+
 
 def _parse_expr_string(ty_str: str, parse_err: str, sources: SourceMap) -> ast.expr:
     """Helper function to parse expressions that are provided as strings.

guppylang/definition/custom.py

@@ -179,7 +179,7 @@ class CustomFunctionDef(CompiledCallableDef):
         has_signature: Whether the function has a declared signature.
     """
 
-    defined_at: AstNode
+    defined_at: AstNode | None
     ty: FunctionType
     call_checker: "CustomCallChecker"
     call_compiler: "CustomInoutCallCompiler"

guppylang/definition/wasm.py

@@ -0,0 +1,58 @@
+from typing import TYPE_CHECKING
+
+from guppylang.ast_util import AstNode
+from guppylang.checker.errors.wasm import (
+    FirstArgNotModule,
+    UnWasmableType,
+)
+from guppylang.definition.custom import CustomFunctionDef, RawCustomFunctionDef
+from guppylang.error import GuppyError
+from guppylang.span import SourceMap
+from guppylang.tys.builtin import wasm_module_info
+from guppylang.tys.ty import (
+    FuncInput,
+    FunctionType,
+    InputFlags,
+    NoneType,
+    NumericType,
+    TupleType,
+    Type,
+)
+
+if TYPE_CHECKING:
+    from guppylang.checker.core import Globals
+
+
+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(
+                ty
+            ) is not None:
+                pass
+            case FuncInput(ty=ty):
+                raise GuppyError(FirstArgNotModule(loc, ty))
+        for inp in fun_ty.inputs[1:]:
+            if not self.is_type_wasmable(inp.ty):
+                raise GuppyError(UnWasmableType(loc, inp.ty))
+        if not self.is_type_wasmable(fun_ty.output):
+            match fun_ty.output:
+                case NoneType():
+                    pass
+                case _:
+                    raise GuppyError(UnWasmableType(loc, fun_ty.output))
+
+    def is_type_wasmable(self, ty: Type) -> bool:
+        match ty:
+            case NumericType():
+                return True
+            case TupleType(element_types=tys):
+                return all(self.is_type_wasmable(ty) for ty in tys)
+
+        return False
+
+    def parse(self, globals: "Globals", sources: SourceMap) -> "CustomFunctionDef":
+        parsed = super().parse(globals, sources)
+        self.sanitise_type(parsed.defined_at, parsed.ty)
+        return parsed

guppylang/std/_internal/checker.py

@@ -14,6 +14,7 @@
 from guppylang.checker.expr_checker import (
     ExprChecker,
     ExprSynthesizer,
+    check_call,
     check_num_args,
     check_type_against,
     synthesize_call,
@@ -557,3 +558,16 @@ def synthesize(self, args: list[ast.expr]) -> tuple[ast.expr, Type]:
         assert len(inst) == 0, "func_ty is not generic"
         node = BarrierExpr(args=args, func_ty=func_ty)
         return with_loc(self.node, node), ret_ty
+
+
+class WasmCallChecker(CustomCallChecker):
+    def check(self, args: list[ast.expr], ty: Type) -> tuple[ast.expr, Subst]:
+        # Use default implementation from the expression checker
+        args, subst, inst = check_call(self.func.ty, args, ty, self.node, self.ctx)
+
+        return GlobalCall(def_id=self.func.id, args=args, type_args=inst), subst
+
+    def synthesize(self, args: list[ast.expr]) -> tuple[ast.expr, Type]:
+        # Use default implementation from the expression checker
+        args, ty, inst = synthesize_call(self.func.ty, args, self.node, self.ctx)
+        return GlobalCall(def_id=self.func.id, args=args, type_args=inst), ty

guppylang/std/_internal/compiler/tket2_exts.py

@@ -1,3 +1,8 @@
+from dataclasses import dataclass
+
+import hugr.model
+import hugr.std
+from hugr import val
 from tket2_exts import (
     debug,
     futures,
@@ -8,26 +13,55 @@
     quantum,
     result,
     rotation,
+    wasm,
 )
 
 BOOL_EXTENSION = opaque_bool()
+DEBUG_EXTENSION = debug()
 FUTURES_EXTENSION = futures()
 QSYSTEM_EXTENSION = qsystem()
 QSYSTEM_RANDOM_EXTENSION = qsystem_random()
 QSYSTEM_UTILS_EXTENSION = qsystem_utils()
 QUANTUM_EXTENSION = quantum()
 RESULT_EXTENSION = result()
 ROTATION_EXTENSION = rotation()
-DEBUG_EXTENSION = debug()
+WASM_EXTENSION = wasm()
 
 TKET2_EXTENSIONS = [
     BOOL_EXTENSION,
+    DEBUG_EXTENSION,
     FUTURES_EXTENSION,
     QSYSTEM_EXTENSION,
     QSYSTEM_RANDOM_EXTENSION,
     QSYSTEM_UTILS_EXTENSION,
     QUANTUM_EXTENSION,
     RESULT_EXTENSION,
     ROTATION_EXTENSION,
-    DEBUG_EXTENSION,
+    WASM_EXTENSION,
 ]
+
+
+@dataclass(frozen=True)
+class ConstWasmModule(val.ExtensionValue):
+    """Python wrapper for the tket2 ConstWasmModule type"""
+
+    wasm_file: str
+    wasm_hash: int
+
+    def to_value(self) -> val.Extension:
+        ty = WASM_EXTENSION.get_type("module").instantiate([])
+
+        name = "tket2.wasm.ConstWasmModule"
+        payload = {"name": self.wasm_file, "hash": self.wasm_hash}
+        return val.Extension(name, typ=ty, val=payload, extensions=["tket2.wasm"])
+
+    def __str__(self) -> str:
+        return (
+            f"ConstWasmModule(wasm_file={self.wasm_file}, wasm_hash={self.wasm_hash})"
+        )
+
+    def to_model(self) -> hugr.model.Term:
+        file_tm = hugr.model.Literal(self.wasm_file)
+        hash_tm = hugr.model.Literal(self.wasm_hash)
+
+        return hugr.model.Apply("tket2.wasm.ConstWasmModule", [file_tm, hash_tm])