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

guppylang_internals/compiler/expr_compiler.py

@@ -144,9 +144,9 @@ class ExprCompiler(CompilerBase, AstVisitor[Wire]):
         """
         old = self.dfg
         # Check that the input names are unique
-        assert len({inp.place.id for inp in inputs}) == len(
-            inputs
-        ), "Inputs are not unique"
+        assert len({inp.place.id for inp in inputs}) == len(inputs), (
+            "Inputs are not unique"
+        )
         self.dfg = DFContainer(builder, self.ctx, self.dfg.locals.copy())
         hugr_input = builder.input_node
         for input_node, wire in zip(inputs, hugr_input, strict=True):
@@ -325,14 +325,7 @@ class ExprCompiler(CompilerBase, AstVisitor[Wire]):
 
     def _pack_returns(self, returns: Sequence[Wire], return_ty: Type) -> Wire:
         """Groups function return values into a tuple"""
-        if isinstance(return_ty, TupleType | NoneType) and not return_ty.preserve:
-            types = type_to_row(return_ty)
-            assert len(returns) == len(types)
-            return self._pack_tuple(returns, types)
-        assert (
-            len(returns) == 1
-        ), f"Expected a single return value. Got {returns}. return type {return_ty}"
-        return returns[0]
+        return pack_returns(returns, return_ty, self.builder, self.ctx)
 
     def _update_inout_ports(
         self,
@@ -394,9 +387,9 @@ class ExprCompiler(CompilerBase, AstVisitor[Wire]):
                 func, func_ty, remaining_args
             )
             rets.extend(outs)
-        assert (
-            remaining_args == []
-        ), "Not all function arguments were consumed after a tensor call"
+        assert remaining_args == [], (
+            "Not all function arguments were consumed after a tensor call"
+        )
         return self._pack_returns(rets, node.tensor_ty.output)
 
     def _compile_tensor_with_leftovers(
@@ -760,6 +753,35 @@ def expr_to_row(expr: ast.expr) -> list[ast.expr]:
     return expr.elts if isinstance(expr, ast.Tuple) else [expr]
 
 
+def pack_returns(
+    returns: Sequence[Wire],
+    return_ty: Type,
+    builder: DfBase[ops.DfParentOp],
+    ctx: CompilerContext,
+) -> Wire:
+    """Groups function return values into a tuple"""
+    if isinstance(return_ty, TupleType | NoneType) and not return_ty.preserve:
+        types = type_to_row(return_ty)
+        assert len(returns) == len(types)
+        hugr_tys = [t.to_hugr(ctx) for t in types]
+        return builder.add_op(ops.MakeTuple(hugr_tys), *returns)
+    assert len(returns) == 1, (
+        f"Expected a single return value. Got {returns}. return type {return_ty}"
+    )
+    return returns[0]
+
+
+def unpack_wire(
+    wire: Wire, return_ty: Type, builder: DfBase[ops.DfParentOp], ctx: CompilerContext
+) -> list[Wire]:
+    """The inverse of `pack_returns`"""
+    if isinstance(return_ty, TupleType | NoneType) and not return_ty.preserve:
+        types = type_to_row(return_ty)
+        hugr_tys = [t.to_hugr(ctx) for t in types]
+        return list(builder.add_op(ops.UnpackTuple(hugr_tys), wire).outputs())
+    return [wire]
+
+
 def instantiation_needs_unpacking(func_ty: FunctionType, inst: Inst) -> bool:
     """Checks if instantiating a polymorphic makes it return a row."""
     if isinstance(func_ty.output, BoundTypeVar):

guppylang_internals/compiler/modifier_compiler.py

@@ -8,7 +8,7 @@ from guppylang_internals.checker.modifier_checker import non_copyable_front_othe
 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.definition.function import add_unitarity_metadata
+from guppylang_internals.definition.metadata import add_metadata
 from guppylang_internals.nodes import CheckedModifiedBlock, PlaceNode
 from guppylang_internals.std._internal.compiler.array import (
     array_new,
@@ -57,7 +57,10 @@ def compile_modified_block(
     func_builder = dfg.builder.module_root_builder().define_function(
         str(modified_block), hugr_ty.input, hugr_ty.output
     )
-    add_unitarity_metadata(func_builder, modified_block.ty.unitary_flags)
+    add_metadata(
+        func_builder,
+        additional_metadata={"unitary": modified_block.ty.unitary_flags.value},
+    )
 
     # compile body
     cfg = compile_cfg(modified_block.cfg, func_builder, func_builder.inputs(), ctx)

guppylang_internals/decorator.py

@@ -4,10 +4,10 @@ import inspect
 import pathlib
 from typing import TYPE_CHECKING, ParamSpec, TypeVar, overload
 
+from guppylang.defs import GuppyDefinition, GuppyFunctionDefinition
 from hugr import ops
 from hugr import tys as ht
 
-from guppylang.defs import GuppyDefinition, GuppyFunctionDefinition
 from guppylang_internals.compiler.core import (
     CompilerContext,
     GlobalConstId,
@@ -26,7 +26,7 @@ from guppylang_internals.definition.ty import OpaqueTypeDef, TypeDef
 from guppylang_internals.definition.wasm import RawWasmFunctionDef
 from guppylang_internals.dummy_decorator import _dummy_custom_decorator, sphinx_running
 from guppylang_internals.engine import DEF_STORE
-from guppylang_internals.error import GuppyError
+from guppylang_internals.error import GuppyError, pretty_errors
 from guppylang_internals.std._internal.checker import WasmCallChecker
 from guppylang_internals.std._internal.compiler.wasm import (
     WasmModuleCallCompiler,
@@ -193,7 +193,7 @@ def custom_type(
             params or [],
             not copyable,
             not droppable,
-            mk_hugr_ty,
+            mk_hugr_ty,  # type: ignore[arg-type]
             bound,
         )
         DEF_STORE.register_def(defn, get_calling_frame())
@@ -207,6 +207,7 @@ def custom_type(
     return dec
 
 
+@pretty_errors
 def wasm_module(
     filename: str,
 ) -> Callable[[builtins.type[T]], GuppyDefinition]:
@@ -252,6 +253,7 @@ def ext_module_decorator(
     def fun(
         filename: str, module: str | None
     ) -> Callable[[builtins.type[T]], GuppyDefinition]:
+        @pretty_errors
         def dec(cls: builtins.type[T]) -> GuppyDefinition:
             # N.B. Only one module per file and vice-versa
             ext_module = type_def(

guppylang_internals/definition/common.py

@@ -163,6 +163,7 @@ class MonomorphizableDef(Definition):
         module: DefinitionBuilder[OpVar],
         mono_args: "PartiallyMonomorphizedArgs",
         ctx: "CompilerContext",
+        parent_ty: "RawDef | None" = None,
     ) -> "MonomorphizedDef":
         """Adds a Hugr node for the (partially) monomorphized definition to the provided
         Hugr module.

guppylang_internals/definition/custom.py

@@ -134,7 +134,7 @@ class RawCustomFunctionDef(ParsableDef):
         """
         from guppylang_internals.definition.function import parse_py_func
 
-        func_ast, docstring = parse_py_func(self.python_func, sources)
+        func_ast, _docstring = parse_py_func(self.python_func, sources)
         if not has_empty_body(func_ast):
             raise GuppyError(BodyNotEmptyError(func_ast.body[0], self.name))
         sig = self.signature or self._get_signature(func_ast, globals)
@@ -479,7 +479,7 @@ class BoolOpCompiler(CustomInoutCallCompiler):
             for res in result
         ]
         return CallReturnWires(
-            regular_returns=converted_result,
+            regular_returns=converted_result,  # type: ignore[arg-type]
             inout_returns=[],
         )
 

guppylang_internals/definition/declaration.py

@@ -120,9 +120,9 @@ class CheckedFunctionDecl(RawFunctionDecl, CompilableDef, CallableDef):
         self, module: DefinitionBuilder[OpVar], ctx: CompilerContext
     ) -> "CompiledFunctionDecl":
         """Adds a Hugr `FuncDecl` node for this function to the Hugr."""
-        assert isinstance(
-            module, hf.Module
-        ), "Functions can only be declared in modules"
+        assert isinstance(module, hf.Module), (
+            "Functions can only be declared in modules"
+        )
         module: hf.Module = module
 
         node = module.declare_function(self.name, self.ty.to_hugr_poly(ctx))

guppylang_internals/definition/function.py

@@ -31,8 +31,10 @@ from guppylang_internals.definition.common import (
     MonomorphizableDef,
     MonomorphizedDef,
     ParsableDef,
+    RawDef,
     UnknownSourceError,
 )
+from guppylang_internals.definition.metadata import GuppyMetadata, add_metadata
 from guppylang_internals.definition.value import (
     CallableDef,
     CallReturnWires,
@@ -72,13 +74,22 @@ class RawFunctionDef(ParsableDef):
 
     unitary_flags: UnitaryFlags = field(default=UnitaryFlags.NoFlags, kw_only=True)
 
+    metadata: GuppyMetadata | None = field(default=None, kw_only=True)
+
     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, self.id, unitary_flags=self.unitary_flags
         )
-        return ParsedFunctionDef(self.id, self.name, func_ast, ty, docstring)
+        return ParsedFunctionDef(
+            self.id,
+            self.name,
+            func_ast,
+            ty,
+            docstring,
+            metadata=self.metadata,
+        )
 
 
 @dataclass(frozen=True)
@@ -103,6 +114,8 @@ class ParsedFunctionDef(CheckableDef, CallableDef):
 
     description: str = field(default="function", init=False)
 
+    metadata: GuppyMetadata | None = field(default=None, kw_only=True)
+
     def check(self, globals: Globals) -> "CheckedFunctionDef":
         """Type checks the body of the function."""
         # Add python variable scope to the globals
@@ -114,6 +127,7 @@ class ParsedFunctionDef(CheckableDef, CallableDef):
             self.ty,
             self.docstring,
             cfg,
+            metadata=self.metadata,
         )
 
     def check_call(
@@ -164,6 +178,7 @@ class CheckedFunctionDef(ParsedFunctionDef, MonomorphizableDef):
         module: DefinitionBuilder[OpVar],
         mono_args: "PartiallyMonomorphizedArgs",
         ctx: "CompilerContext",
+        parent_ty: "RawDef | None" = None,
     ) -> "CompiledFunctionDef":
         """Adds a Hugr `FuncDefn` node for the (partially) monomorphized function to the
         Hugr.
@@ -172,12 +187,21 @@ class CheckedFunctionDef(ParsedFunctionDef, MonomorphizableDef):
         access to the other compiled functions yet. The body is compiled later in
         `CompiledFunctionDef.compile_inner()`.
         """
+        if parent_ty is None:
+            hugr_func_name = self.name
+        else:
+            hugr_func_name = f"{parent_ty.name}.{self.name}"
+
         mono_ty = self.ty.instantiate_partial(mono_args)
         hugr_ty = mono_ty.to_hugr_poly(ctx)
         func_def = module.module_root_builder().define_function(
-            self.name, hugr_ty.body.input, hugr_ty.body.output, hugr_ty.params
+            hugr_func_name, hugr_ty.body.input, hugr_ty.body.output, hugr_ty.params
+        )
+        add_metadata(
+            func_def,
+            self.metadata,
+            additional_metadata={"unitary": self.ty.unitary_flags.value},
         )
-        add_unitarity_metadata(func_def, self.ty.unitary_flags)
         return CompiledFunctionDef(
             self.id,
             self.name,
@@ -187,6 +211,7 @@ class CheckedFunctionDef(ParsedFunctionDef, MonomorphizableDef):
             self.docstring,
             self.cfg,
             func_def,
+            metadata=self.metadata,
         )
 
 
@@ -305,8 +330,3 @@ def parse_source(source_lines: list[str], line_offset: int) -> tuple[str, ast.AS
     else:
         node = ast.parse(source).body[0]
     return source, node, line_offset
-
-
-def add_unitarity_metadata(func: hf.Function, flags: UnitaryFlags) -> None:
-    """Stores unitarity annotations in the metadate of a Hugr function definition."""
-    func.metadata["unitary"] = flags.value

guppylang_internals/definition/metadata.py

@@ -0,0 +1,87 @@
+"""Metadata attached to objects within the Guppy compiler, both for internal use and to
+attach to HUGR nodes for lower-level processing."""
+
+from abc import ABC
+from dataclasses import dataclass, field, fields
+from typing import Any, ClassVar, Generic, TypeVar
+
+from hugr.hugr.node_port import ToNode
+
+from guppylang_internals.diagnostic import Fatal
+from guppylang_internals.error import GuppyError
+
+T = TypeVar("T")
+
+
+@dataclass(init=True, kw_only=True)
+class GuppyMetadataValue(ABC, Generic[T]):
+    """A template class for a metadata value within the scope of the Guppy compiler.
+    Implementations should provide the `key` in reverse-URL format."""
+
+    key: ClassVar[str]
+    value: T | None = None
+
+
+class MetadataMaxQubits(GuppyMetadataValue[int]):
+    key = "tket.hint.max_qubits"
+
+
+@dataclass(frozen=True, init=True, kw_only=True)
+class GuppyMetadata:
+    """DTO for metadata within the scope of the guppy compiler for attachment to HUGR
+    nodes. See `add_metadata`."""
+
+    max_qubits: MetadataMaxQubits = field(default_factory=MetadataMaxQubits, init=False)
+
+    @classmethod
+    def reserved_keys(cls) -> set[str]:
+        return {f.type.key for f in fields(GuppyMetadata)}  # type: ignore[union-attr]
+
+
+@dataclass(frozen=True)
+class MetadataAlreadySetError(Fatal):
+    title: ClassVar[str] = "Metadata key already set"
+    message: ClassVar[str] = "Received two values for the metadata key `{key}`"
+    key: str
+
+
+@dataclass(frozen=True)
+class ReservedMetadataKeysError(Fatal):
+    title: ClassVar[str] = "Metadata key is reserved"
+    message: ClassVar[str] = (
+        "The following metadata keys are reserved by Guppy but also provided in "
+        "additional metadata: `{keys}`"
+    )
+    keys: set[str]
+
+
+def add_metadata(
+    node: ToNode,
+    metadata: GuppyMetadata | None = None,
+    *,
+    additional_metadata: dict[str, Any] | None = None,
+) -> None:
+    """Adds metadata to the given node using the keys defined through inheritors of
+    `GuppyMetadataValue` defined in the `GuppyMetadata` class.
+
+    Additional metadata is forwarded as is, although the given dictionary may not
+    contain any keys already reserved by fields in `GuppyMetadata`.
+    """
+    if metadata is not None:
+        for f in fields(GuppyMetadata):
+            data: GuppyMetadataValue[Any] = getattr(metadata, f.name)
+            if data.key in node.metadata:
+                raise GuppyError(MetadataAlreadySetError(None, data.key))
+            if data.value is not None:
+                node.metadata[data.key] = data.value
+
+    if additional_metadata is not None:
+        reserved_keys = GuppyMetadata.reserved_keys()
+        used_reserved_keys = reserved_keys.intersection(additional_metadata.keys())
+        if len(used_reserved_keys) > 0:
+            raise GuppyError(ReservedMetadataKeysError(None, keys=used_reserved_keys))
+
+        for key, value in additional_metadata.items():
+            if key in node.metadata:
+                raise GuppyError(MetadataAlreadySetError(None, key))
+            node.metadata[key] = value

guppylang_internals/definition/overloaded.py

@@ -1,4 +1,5 @@
 import ast
+import copy
 from contextlib import suppress
 from dataclasses import dataclass, field
 from typing import ClassVar, NoReturn
@@ -86,7 +87,11 @@ class OverloadedFunctionDef(CompiledCallableDef, CallableDef):
             assert isinstance(defn, CallableDef)
             available_sigs.append(defn.ty)
             with suppress(GuppyError):
-                return defn.check_call(args, ty, node, ctx)
+                # check_call may modify args and node,
+                # thus we deepcopy them before passing in the function
+                node_copy = copy.deepcopy(node)
+                args_copy = copy.deepcopy(args)
+                return defn.check_call(args_copy, ty, node_copy, ctx)
         return self._call_error(args, node, ctx, available_sigs, ty)
 
     def synthesize_call(
@@ -98,7 +103,11 @@ class OverloadedFunctionDef(CompiledCallableDef, CallableDef):
             assert isinstance(defn, CallableDef)
             available_sigs.append(defn.ty)
             with suppress(GuppyError):
-                return defn.synthesize_call(args, node, ctx)
+                # synthesize_call may modify args and node,
+                # thus we deepcopy them before passing in the function
+                node_copy = copy.deepcopy(node)
+                args_copy = copy.deepcopy(args)
+                return defn.synthesize_call(args_copy, node_copy, ctx)
         return self._call_error(args, node, ctx, available_sigs)
 
     def _call_error(

guppylang_internals/definition/pytket_circuits.py

@@ -3,18 +3,17 @@ from dataclasses import dataclass, field
 from typing import Any, cast
 
 import hugr.build.function as hf
+from guppylang.defs import GuppyDefinition
 from hugr import Node, Wire, envelope, ops, val
 from hugr import tys as ht
 from hugr.build.dfg import DefinitionBuilder, OpVar
 from hugr.envelope import EnvelopeConfig
 from hugr.std.float import FLOAT_T
+from pytket.circuit import Circuit
 
 from guppylang_internals.ast_util import AstNode, has_empty_body, with_loc
 from guppylang_internals.checker.core import Context, Globals
-from guppylang_internals.checker.errors.comptime_errors import (
-    PytketSignatureMismatch,
-    TketNotInstalled,
-)
+from guppylang_internals.checker.errors.comptime_errors import PytketSignatureMismatch
 from guppylang_internals.checker.expr_checker import check_call, synthesize_call
 from guppylang_internals.checker.func_checker import (
     check_signature,
@@ -46,6 +45,7 @@ from guppylang_internals.std._internal.compiler.array import (
     array_new,
     array_unpack,
 )
+from guppylang_internals.std._internal.compiler.quantum import from_halfturns_unchecked
 from guppylang_internals.std._internal.compiler.tket_bool import OpaqueBool, make_opaque
 from guppylang_internals.tys.builtin import array_type, bool_type, float_type
 from guppylang_internals.tys.subst import Inst, Subst
@@ -230,17 +230,20 @@ class ParsedPytketDef(CallableDef, CompilableDef):
                         )
                         lex_params = list(unpack_result)
                     param_order = cast(
-                        list[str], hugr_func.metadata["TKET1.input_parameters"]
+                        "list[str]", hugr_func.metadata["TKET1.input_parameters"]
                     )
                     lex_names = sorted(param_order)
                     name_to_param = dict(zip(lex_names, lex_params, strict=True))
                     angle_wires = [name_to_param[name] for name in param_order]
-                    # Need to convert all angles to floats.
+                    # Need to convert all angles to rotations.
                     for angle in angle_wires:
                         [halfturns] = outer_func.add_op(
                             ops.UnpackTuple([FLOAT_T]), angle
                         )
-                        param_wires.append(halfturns)
+                        rotation = outer_func.add_op(
+                            from_halfturns_unchecked(), halfturns
+                        )
+                        param_wires.append(rotation)
 
                 # Pass all arguments to call node.
                 call_node = outer_func.call(
@@ -365,69 +368,49 @@ class CompiledPytketDef(ParsedPytketDef, CompiledCallableDef, CompiledHugrNodeDe
 
 
 def _signature_from_circuit(
-    input_circuit: Any,
+    input_circuit: Circuit,
     defined_at: ToSpan | None,
     use_arrays: bool = False,
 ) -> FunctionType:
     """Helper function for inferring a function signature from a pytket circuit."""
     # May want to set proper unitary flags in the future.
-    try:
-        import pytket
-
-        if isinstance(input_circuit, pytket.circuit.Circuit):
-            try:
-                import tket  # type: ignore[import-untyped, import-not-found, unused-ignore]  # noqa: F401
-
-                from guppylang.defs import GuppyDefinition
-                from guppylang.std.angles import angle
-                from guppylang.std.quantum import qubit
-
-                assert isinstance(qubit, GuppyDefinition)
-                qubit_ty = cast(TypeDef, qubit.wrapped).check_instantiate([])
-
-                angle_defn = ENGINE.get_checked(angle.id)  # type: ignore[attr-defined]
-                assert isinstance(angle_defn, TypeDef)
-                angle_ty = angle_defn.check_instantiate([])
-
-                if use_arrays:
-                    inputs = [
-                        FuncInput(array_type(qubit_ty, q_reg.size), InputFlags.Inout)
-                        for q_reg in input_circuit.q_registers
-                    ]
-                    if len(input_circuit.free_symbols()) != 0:
-                        inputs.append(
-                            FuncInput(
-                                array_type(angle_ty, len(input_circuit.free_symbols())),
-                                InputFlags.NoFlags,
-                            )
-                        )
-                    outputs = [
-                        array_type(bool_type(), c_reg.size)
-                        for c_reg in input_circuit.c_registers
-                    ]
-                    circuit_signature = FunctionType(
-                        inputs,
-                        row_to_type(outputs),
-                    )
-                else:
-                    param_inputs = [
-                        FuncInput(angle_ty, InputFlags.NoFlags)
-                        for _ in range(len(input_circuit.free_symbols()))
-                    ]
-                    circuit_signature = FunctionType(
-                        [FuncInput(qubit_ty, InputFlags.Inout)] * input_circuit.n_qubits
-                        + param_inputs,
-                        row_to_type([bool_type()] * input_circuit.n_bits),
-                    )
-            except ImportError:
-                err = TketNotInstalled(defined_at)
-                err.add_sub_diagnostic(TketNotInstalled.InstallInstruction(None))
-                raise GuppyError(err) from None
-        else:
-            pass
-    except ImportError:
-        raise InternalGuppyError(
-            "Pytket error should have been caught earlier"
-        ) from None
+    from guppylang.std.angles import angle  # Avoid circular imports
+    from guppylang.std.quantum import qubit
+
+    assert isinstance(qubit, GuppyDefinition)
+    qubit_ty = cast("TypeDef", qubit.wrapped).check_instantiate([])
+
+    angle_defn = ENGINE.get_checked(angle.id)  # type: ignore[attr-defined]
+    assert isinstance(angle_defn, TypeDef)
+    angle_ty = angle_defn.check_instantiate([])
+
+    if use_arrays:
+        inputs = [
+            FuncInput(array_type(qubit_ty, q_reg.size), InputFlags.Inout)
+            for q_reg in input_circuit.q_registers
+        ]
+        if len(input_circuit.free_symbols()) != 0:
+            inputs.append(
+                FuncInput(
+                    array_type(angle_ty, len(input_circuit.free_symbols())),
+                    InputFlags.NoFlags,
+                )
+            )
+        outputs = [
+            array_type(bool_type(), c_reg.size) for c_reg in input_circuit.c_registers
+        ]
+        circuit_signature = FunctionType(
+            inputs,
+            row_to_type(outputs),
+        )
     else:
-        return circuit_signature
+        param_inputs = [
+            FuncInput(angle_ty, InputFlags.NoFlags)
+            for _ in range(len(input_circuit.free_symbols()))
+        ]
+        circuit_signature = FunctionType(
+            [FuncInput(qubit_ty, InputFlags.Inout)] * input_circuit.n_qubits
+            + param_inputs,
+            row_to_type([bool_type()] * input_circuit.n_bits),
+        )
+    return circuit_signature

guppylang_internals/definition/value.py

@@ -55,7 +55,7 @@ class CallableDef(ValueDef):
         raise RuntimeError("Guppy functions can only be called in a Guppy context")
 
 
-class CompiledCallableDef(CallableDef, CompiledValueDef):
+class CompiledCallableDef(CallableDef, CompiledValueDef):  # type: ignore[misc, unused-ignore]
     """Abstract base class a global module-level function."""
 
     ty: FunctionType

guppylang_internals/definition/wasm.py

@@ -38,9 +38,9 @@ class RawWasmFunctionDef(RawCustomFunctionDef):
     def sanitise_type(self, loc: AstNode, fun_ty: FunctionType) -> None:
         # Place to highlight in error messages
         match fun_ty.inputs:
-            case [FuncInput(ty=ty, flags=InputFlags.Inout), *args] if wasm_module_name(
-                ty
-            ) is not None:
+            case [FuncInput(ty=ty, flags=InputFlags.Inout), *args] if (
+                wasm_module_name(ty) is not None
+            ):
                 for inp in args:
                     if not self.is_type_wasmable(inp.ty):
                         raise GuppyError(UnWasmableType(loc, inp.ty))