guppylang-internals 0.23.0__py3-none-any.whl → 0.25.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
@@ -85,7 +84,7 @@ class RawPytketDef(ParsableDef):
         if not has_empty_body(func_ast):
             # Function stub should have empty body.
             raise GuppyError(BodyNotEmptyError(func_ast.body[0], self.name))
-        stub_signature = check_signature(func_ast, globals)
+        stub_signature = check_signature(func_ast, globals, self.id)
 
         # Compare signatures.
         circuit_signature = _signature_from_circuit(self.input_circuit, self.defined_at)
@@ -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

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."""
@@ -130,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
@@ -211,15 +215,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 +375,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 +391,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

@@ -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
@@ -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
@@ -36,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

@@ -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/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,6 +6,7 @@ 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
@@ -166,17 +167,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 +178,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.
 
@@ -445,3 +423,126 @@ 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}")
+
+
+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