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

guppylang_internals/definition/pytket_circuits.py

@@ -46,7 +46,6 @@ from guppylang_internals.std._internal.compiler.array import (
     array_new,
     array_unpack,
 )
-from guppylang_internals.std._internal.compiler.prelude import build_unwrap
 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
@@ -195,17 +194,9 @@ class ParsedPytketDef(CallableDef, CompilableDef):
                     # them into separate wires.
                     for i, q_reg in enumerate(self.input_circuit.q_registers):
                         reg_wire = outer_func.inputs()[i]
-                        opt_elem_wires = outer_func.add_op(
-                            array_unpack(ht.Option(ht.Qubit), q_reg.size), reg_wire
+                        elem_wires = outer_func.add_op(
+                            array_unpack(ht.Qubit, q_reg.size), reg_wire
                         )
-                        elem_wires = [
-                            build_unwrap(
-                                outer_func,
-                                opt_elem,
-                                "Internal error: unwrapping of array element failed",
-                            )
-                            for opt_elem in opt_elem_wires
-                        ]
                         input_list.extend(elem_wires)
 
                 else:
@@ -219,7 +210,8 @@ class ParsedPytketDef(CallableDef, CompilableDef):
                 ]
 
                 # Symbolic parameters (if present) get passed after qubits and bools.
-                has_params = len(self.input_circuit.free_symbols()) != 0
+                num_params = len(self.input_circuit.free_symbols())
+                has_params = num_params != 0
                 if has_params and "TKET1.input_parameters" not in hugr_func.metadata:
                     raise InternalGuppyError(
                         "Parameter metadata is missing from pytket circuit HUGR"
@@ -230,26 +222,17 @@ class ParsedPytketDef(CallableDef, CompilableDef):
                 if has_params:
                     lex_params: list[Wire] = list(outer_func.inputs()[offset:])
                     if self.use_arrays:
-                        opt_param_wires = outer_func.add_op(
+                        unpack_result = outer_func.add_op(
                             array_unpack(
-                                ht.Option(ht.Tuple(float_type().to_hugr(ctx))),
-                                q_reg.size,
+                                ht.Tuple(float_type().to_hugr(ctx)), num_params
                             ),
                             lex_params[0],
                         )
-                        lex_params = [
-                            build_unwrap(
-                                outer_func,
-                                opt_param,
-                                "Internal error: unwrapping of array element failed",
-                            )
-                            for opt_param in opt_param_wires
-                        ]
+                        lex_params = list(unpack_result)
                     param_order = cast(
                         list[str], hugr_func.metadata["TKET1.input_parameters"]
                     )
                     lex_names = sorted(param_order)
-                    assert len(lex_names) == len(lex_params)
                     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.
@@ -280,34 +263,23 @@ class ParsedPytketDef(CallableDef, CompilableDef):
                 ]
 
                 if self.use_arrays:
-
-                    def pack(elems: list[Wire], elem_ty: ht.Type, length: int) -> Wire:
-                        elem_opts = [
-                            outer_func.add_op(ops.Some(elem_ty), elem) for elem in elems
-                        ]
-                        return outer_func.add_op(
-                            array_new(ht.Option(elem_ty), length), *elem_opts
-                        )
-
                     array_wires: list[Wire] = []
                     wire_idx = 0
                     # First pack bool results into an array.
                     for c_reg in self.input_circuit.c_registers:
                         array_wires.append(
-                            pack(
-                                wires[wire_idx : wire_idx + c_reg.size],
-                                OpaqueBool,
-                                c_reg.size,
+                            outer_func.add_op(
+                                array_new(OpaqueBool, c_reg.size),
+                                *wires[wire_idx : wire_idx + c_reg.size],
                             )
                         )
                         wire_idx = wire_idx + c_reg.size
                     # Then the borrowed qubits also need to be put back into arrays.
                     for q_reg in self.input_circuit.q_registers:
                         array_wires.append(
-                            pack(
-                                wires[wire_idx : wire_idx + q_reg.size],
-                                ht.Qubit,
-                                q_reg.size,
+                            outer_func.add_op(
+                                array_new(ht.Qubit, q_reg.size),
+                                *wires[wire_idx : wire_idx + q_reg.size],
                             )
                         )
                         wire_idx = wire_idx + q_reg.size
@@ -398,6 +370,7 @@ def _signature_from_circuit(
     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
 

guppylang_internals/definition/struct.py

@@ -131,10 +131,13 @@ class RawStructDef(TypeDef, ParsableDef):
             if cls_def.type_params:
                 first, last = cls_def.type_params[0], cls_def.type_params[-1]
                 params_span = Span(to_span(first).start, to_span(last).end)
-                params = [
-                    parse_parameter(node, idx, globals)
-                    for idx, node in enumerate(cls_def.type_params)
-                ]
+                param_vars_mapping: dict[str, Parameter] = {}
+                for idx, param_node in enumerate(cls_def.type_params):
+                    param = parse_parameter(
+                        param_node, idx, globals, param_vars_mapping
+                    )
+                    param_vars_mapping[param.name] = param
+                    params.append(param)
 
         # The only base we allow is `Generic[...]` to specify generic parameters with
         # the legacy syntax
@@ -270,13 +273,16 @@ class CheckedStructDef(TypeDef, CompiledDef):
 
         constructor_sig = FunctionType(
             inputs=[
-                FuncInput(f.ty, InputFlags.Owned if f.ty.linear else InputFlags.NoFlags)
+                FuncInput(
+                    f.ty,
+                    InputFlags.Owned if f.ty.linear else InputFlags.NoFlags,
+                    f.name,
+                )
                 for f in self.fields
             ],
             output=StructType(
                 defn=self, args=[p.to_bound(i) for i, p in enumerate(self.params)]
             ),
-            input_names=[f.name for f in self.fields],
             params=self.params,
         )
         constructor_def = CustomFunctionDef(
@@ -314,7 +320,7 @@ def parse_py_class(
         raise GuppyError(UnknownSourceError(None, cls))
 
     # We can't rely on `inspect.getsourcelines` since it doesn't work properly for
-    # classes prior to Python 3.13. See https://github.com/CQCL/guppylang/issues/1107.
+    # classes prior to Python 3.13. See https://github.com/quantinuum/guppylang/issues/1107.
     # Instead, we reproduce the behaviour of Python >= 3.13 using the `__firstlineno__`
     # attribute. See https://github.com/python/cpython/blob/3.13/Lib/inspect.py#L1052.
     # In the decorator, we make sure that `__firstlineno__` is set, even if we're not

guppylang_internals/definition/ty.py

@@ -2,7 +2,7 @@ from abc import abstractmethod
 from collections.abc import Callable, Sequence
 from dataclasses import dataclass, field
 
-from hugr import tys
+from hugr import tys as ht
 
 from guppylang_internals.ast_util import AstNode
 from guppylang_internals.definition.common import CompiledDef, Definition
@@ -42,8 +42,8 @@ class OpaqueTypeDef(TypeDef, CompiledDef):
     params: Sequence[Parameter]
     never_copyable: bool
     never_droppable: bool
-    to_hugr: Callable[[Sequence[Argument], ToHugrContext], tys.Type]
-    bound: tys.TypeBound | None = None
+    to_hugr: Callable[[Sequence[Argument], ToHugrContext], ht.Type]
+    bound: ht.TypeBound | None = None
 
     def check_instantiate(
         self, args: Sequence[Argument], loc: AstNode | None = None

guppylang_internals/definition/wasm.py

@@ -1,3 +1,4 @@
+from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
 from guppylang_internals.ast_util import AstNode
@@ -9,7 +10,8 @@ from guppylang_internals.definition.custom import (
     CustomFunctionDef,
     RawCustomFunctionDef,
 )
-from guppylang_internals.error import GuppyError
+from guppylang_internals.engine import DEF_STORE
+from guppylang_internals.error import GuppyError, GuppyTypeError
 from guppylang_internals.span import SourceMap
 from guppylang_internals.tys.builtin import wasm_module_name
 from guppylang_internals.tys.ty import (
@@ -21,24 +23,35 @@ from guppylang_internals.tys.ty import (
     TupleType,
     Type,
 )
+from guppylang_internals.wasm_util import WasmSigMismatchError
 
 if TYPE_CHECKING:
     from guppylang_internals.checker.core import Globals
 
 
+@dataclass(frozen=True)
 class RawWasmFunctionDef(RawCustomFunctionDef):
-    def sanitise_type(self, loc: AstNode | None, fun_ty: FunctionType) -> None:
+    # If a function is specified in the @wasm decorator by its index in the wasm
+    # file, record what the index was.
+    wasm_index: int | None = field(default=None)
+
+    def sanitise_type(self, loc: AstNode, 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_name(
+        match fun_ty.inputs:
+            case [FuncInput(ty=ty, flags=InputFlags.Inout), *args] if wasm_module_name(
                 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))
+                for inp in args:
+                    if not self.is_type_wasmable(inp.ty):
+                        raise GuppyError(UnWasmableType(loc, inp.ty))
+            case [FuncInput(ty=ty), *_]:
+                raise GuppyError(
+                    FirstArgNotModule(loc).add_sub_diagnostic(
+                        FirstArgNotModule.GotOtherType(loc, ty)
+                    )
+                )
+            case []:
+                raise GuppyError(FirstArgNotModule(loc))
         if not self.is_type_wasmable(fun_ty.output):
             match fun_ty.output:
                 case NoneType():
@@ -46,6 +59,23 @@ class RawWasmFunctionDef(RawCustomFunctionDef):
                 case _:
                     raise GuppyError(UnWasmableType(loc, fun_ty.output))
 
+    def validate_type(self, loc: AstNode, fun_ty: FunctionType) -> None:
+        type_in_wasm: FunctionType = DEF_STORE.wasm_functions[self.id]
+        assert type_in_wasm is not None
+        # Drop the first arg because it should be "self"
+        expected_type = FunctionType(fun_ty.inputs[1:], fun_ty.output)
+
+        if expected_type != type_in_wasm:
+            raise GuppyTypeError(
+                WasmSigMismatchError(loc)
+                .add_sub_diagnostic(
+                    WasmSigMismatchError.Declaration(None, declared=str(expected_type))
+                )
+                .add_sub_diagnostic(
+                    WasmSigMismatchError.Actual(None, actual=str(type_in_wasm))
+                )
+            )
+
     def is_type_wasmable(self, ty: Type) -> bool:
         match ty:
             case NumericType():
@@ -57,5 +87,7 @@ class RawWasmFunctionDef(RawCustomFunctionDef):
 
     def parse(self, globals: "Globals", sources: SourceMap) -> "CustomFunctionDef":
         parsed = super().parse(globals, sources)
+        assert parsed.defined_at is not None
         self.sanitise_type(parsed.defined_at, parsed.ty)
+        self.validate_type(parsed.defined_at, parsed.ty)
         return parsed

guppylang_internals/engine.py

@@ -46,6 +46,7 @@ from guppylang_internals.tys.builtin import (
     string_type_def,
     tuple_type_def,
 )
+from guppylang_internals.tys.ty import FunctionType
 
 if TYPE_CHECKING:
     from guppylang_internals.compiler.core import MonoDefId
@@ -87,6 +88,7 @@ class DefinitionStore:
     raw_defs: dict[DefId, RawDef]
     impls: defaultdict[DefId, dict[str, DefId]]
     impl_parents: dict[DefId, DefId]
+    wasm_functions: dict[DefId, FunctionType]
     frames: dict[DefId, FrameType]
     sources: SourceMap
 
@@ -96,6 +98,7 @@ class DefinitionStore:
         self.impl_parents = {}
         self.frames = {}
         self.sources = SourceMap()
+        self.wasm_functions = {}
 
     def register_def(self, defn: RawDef, frame: FrameType | None) -> None:
         self.raw_defs[defn.id] = defn
@@ -123,6 +126,9 @@ class DefinitionStore:
                     assert frame is not None
                     self.frames[impl_id] = frame
 
+    def register_wasm_function(self, fn_id: DefId, sig: FunctionType) -> None:
+        self.wasm_functions[fn_id] = sig
+
 
 DEF_STORE: DefinitionStore = DefinitionStore()
 
@@ -263,8 +269,8 @@ class CompilationEngine:
             and isinstance(compiled_def, CompiledCallableDef)
             and not isinstance(graph.hugr[compiled_def.hugr_node].op, ops.FuncDecl)
         ):
-            # if compiling a region set it as the HUGR entrypoint
-            # can be loosened after https://github.com/CQCL/hugr/issues/2501 is fixed
+            # if compiling a region set it as the HUGR entrypoint can be
+            # loosened after https://github.com/quantinuum/hugr/issues/2501 is fixed
             graph.hugr.entrypoint = compiled_def.hugr_node
 
         # TODO: Currently the list of extensions is manually managed by the user.
@@ -278,7 +284,7 @@ class CompilationEngine:
             guppylang_internals.compiler.hugr_extension.EXTENSION,
             *self.additional_extensions,
         ]
-        # TODO replace with computed extensions after https://github.com/CQCL/guppylang/issues/550
+        # TODO replace with computed extensions after https://github.com/quantinuum/guppylang/issues/550
         all_used_extensions = [
             *extensions,
             hugr.std.prelude.PRELUDE_EXTENSION,

guppylang_internals/experimental.py

@@ -90,3 +90,8 @@ def check_lists_enabled(loc: AstNode | None = None) -> None:
 def check_capturing_closures_enabled(loc: AstNode | None = None) -> None:
     if not EXPERIMENTAL_FEATURES_ENABLED:
         raise GuppyError(UnsupportedError(loc, "Capturing closures"))
+
+
+def check_modifiers_enabled(loc: AstNode | None = None) -> None:
+    if not EXPERIMENTAL_FEATURES_ENABLED:
+        raise GuppyError(ExperimentalFeatureError(loc, "Modifiers"))

guppylang_internals/nodes.py

@@ -6,9 +6,16 @@ from enum import Enum
 from typing import TYPE_CHECKING, Any
 
 from guppylang_internals.ast_util import AstNode
+from guppylang_internals.span import Span, to_span
 from guppylang_internals.tys.const import Const
 from guppylang_internals.tys.subst import Inst
-from guppylang_internals.tys.ty import FunctionType, StructType, TupleType, Type
+from guppylang_internals.tys.ty import (
+    FunctionType,
+    StructType,
+    TupleType,
+    Type,
+    UnitaryFlags,
+)
 
 if TYPE_CHECKING:
     from guppylang_internals.cfg.cfg import CFG
@@ -249,22 +256,6 @@ class ComptimeExpr(ast.expr):
     _fields = ("value",)
 
 
-class ResultExpr(ast.expr):
-    """A `result(tag, value)` expression."""
-
-    value: ast.expr
-    base_ty: Type
-    #: Array length in case this is an array result, otherwise `None`
-    array_len: Const | None
-    tag: str
-
-    _fields = ("value", "base_ty", "array_len", "tag")
-
-    @property
-    def args(self) -> list[ast.expr]:
-        return [self.value]
-
-
 class ExitKind(Enum):
     ExitShot = 0  # Exit the current shot
     Panic = 1  # Panic the program ending all shots
@@ -274,8 +265,8 @@ class PanicExpr(ast.expr):
     """A `panic(msg, *args)` or `exit(msg, *args)` expression ."""
 
     kind: ExitKind
-    signal: int
-    msg: str
+    signal: ast.expr
+    msg: ast.expr
     values: list[ast.expr]
 
     _fields = ("kind", "signal", "msg", "values")
@@ -292,17 +283,16 @@ class BarrierExpr(ast.expr):
 class StateResultExpr(ast.expr):
     """A `state_result(tag, *args)` expression."""
 
-    tag: str
+    tag_value: Const
+    tag_expr: ast.expr
     args: list[ast.expr]
     func_ty: FunctionType
     #: Array length in case this is an array result, otherwise `None`
     array_len: Const | None
-    _fields = ("tag", "args", "func_ty", "has_array_input")
+    _fields = ("tag_value", "tag_expr", "args", "func_ty", "has_array_input")
 
 
-AnyCall = (
-    LocalCall | GlobalCall | TensorCall | BarrierExpr | ResultExpr | StateResultExpr
-)
+AnyCall = LocalCall | GlobalCall | TensorCall | BarrierExpr | StateResultExpr
 
 
 class InoutReturnSentinel(ast.expr):
@@ -422,3 +412,136 @@ class CheckedNestedFunctionDef(ast.FunctionDef):
         self.cfg = cfg
         self.ty = ty
         self.captured = captured
+
+
+class Dagger(ast.expr):
+    """The dagger modifier"""
+
+    def __init__(self, node: ast.expr) -> None:
+        super().__init__(**node.__dict__)
+
+
+class Control(ast.Call):
+    """The control modifier"""
+
+    ctrl: list[ast.expr]
+    qubit_num: int | Const | None
+
+    _fields = ("ctrl",)
+
+    def __init__(self, node: ast.Call, ctrl: list[ast.expr]) -> None:
+        super().__init__(**node.__dict__)
+        self.ctrl = ctrl
+        self.qubit_num = None
+
+
+class Power(ast.expr):
+    """The power modifier"""
+
+    iter: ast.expr
+
+    _fields = ("iter",)
+
+    def __init__(self, node: ast.expr, iter: ast.expr) -> None:
+        super().__init__(**node.__dict__)
+        self.iter = iter
+
+
+Modifier = Dagger | Control | Power
+
+
+class ModifiedBlock(ast.With):
+    cfg: "CFG"
+    dagger: list[Dagger]
+    control: list[Control]
+    power: list[Power]
+
+    def __init__(self, cfg: "CFG", *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.cfg = cfg
+        self.dagger = []
+        self.control = []
+        self.power = []
+
+    def is_dagger(self) -> bool:
+        return len(self.dagger) % 2 == 1
+
+    def is_control(self) -> bool:
+        return len(self.control) > 0
+
+    def is_power(self) -> bool:
+        return len(self.power) > 0
+
+    def span_ctxt_manager(self) -> Span:
+        return Span(
+            to_span(self.items[0].context_expr).start,
+            to_span(self.items[-1].context_expr).end,
+        )
+
+    def push_modifier(self, modifier: Modifier) -> None:
+        """Pushes a modifier kind onto the modifier."""
+        if isinstance(modifier, Dagger):
+            self.dagger.append(modifier)
+        elif isinstance(modifier, Control):
+            self.control.append(modifier)
+        elif isinstance(modifier, Power):
+            self.power.append(modifier)
+        else:
+            raise TypeError(f"Unknown modifier: {modifier}")
+
+    def flags(self) -> UnitaryFlags:
+        flags = UnitaryFlags.NoFlags
+        if self.is_dagger():
+            flags |= UnitaryFlags.Dagger
+        if self.is_control():
+            flags |= UnitaryFlags.Control
+        if self.is_power():
+            flags |= UnitaryFlags.Power
+        return flags
+
+
+class CheckedModifiedBlock(ast.With):
+    def_id: "DefId"
+    cfg: "CheckedCFG[Place]"
+    dagger: list[Dagger]
+    control: list[Control]
+    power: list[Power]
+
+    #: The type of the body of With block.
+    ty: FunctionType
+    #: Mapping from names to variables captured in the body.
+    captured: Mapping[str, tuple["Variable", AstNode]]
+
+    def __init__(
+        self,
+        def_id: "DefId",
+        cfg: "CheckedCFG[Place]",
+        ty: FunctionType,
+        captured: Mapping[str, tuple["Variable", AstNode]],
+        dagger: list[Dagger],
+        control: list[Control],
+        power: list[Power],
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.def_id = def_id
+        self.cfg = cfg
+        self.ty = ty
+        self.captured = captured
+        self.dagger = dagger
+        self.control = control
+        self.power = power
+
+    def __str__(self) -> str:
+        # generate a function name from the def_id
+        return f"__WithBlock__({self.def_id})"
+
+    def has_dagger(self) -> bool:
+        return len(self.dagger) % 2 == 1
+
+    def has_control(self) -> bool:
+        return any(len(c.ctrl) > 0 for c in self.control)
+
+    def has_power(self) -> bool:
+        return len(self.power) > 0