guppylang-internals 0.21.1__tar.gz → 0.22.0__tar.gz

{guppylang_internals-0.21.1 → guppylang_internals-0.22.0}/CHANGELOG.md

@@ -3,6 +3,25 @@
 First release of `guppylang_internals` package containing refactored out internal components
 from `guppylang`.
 
+## [0.22.0](https://github.com/CQCL/guppylang/compare/guppylang-internals-v0.21.2...guppylang-internals-v0.22.0) (2025-08-11)
+
+
+### ⚠ BREAKING CHANGES
+
+* RangeChecker has been deleted.
+
+### Features
+
+* Add float parameter inputs to symbolic pytket circuits ([#1105](https://github.com/CQCL/guppylang/issues/1105)) ([34c546c](https://github.com/CQCL/guppylang/commit/34c546c3b5787beb839687fdbf4db8bc94f36c4a)), closes [#1076](https://github.com/CQCL/guppylang/issues/1076)
+* Allow custom start and step in `range` ([#1157](https://github.com/CQCL/guppylang/issues/1157)) ([a1b9333](https://github.com/CQCL/guppylang/commit/a1b9333712c74270d5efaaa72f83d6b09047c068))
+* Improve codegen for array unpacking ([#1106](https://github.com/CQCL/guppylang/issues/1106)) ([f375097](https://github.com/CQCL/guppylang/commit/f3750973a719b03d27668a3ae39f58c8424deffc))
+* Insert drop ops for affine values ([#1090](https://github.com/CQCL/guppylang/issues/1090)) ([083133e](https://github.com/CQCL/guppylang/commit/083133e809873fce265bb78547fc3e519cb66ea1))
+
+
+### Bug Fixes
+
+* Fix builtins mock escaping the tracing scope ([#1161](https://github.com/CQCL/guppylang/issues/1161)) ([a27a5c1](https://github.com/CQCL/guppylang/commit/a27a5c19560d76e46678f846476ea86e873ac8ac))
+
 ## [0.21.1](https://github.com/CQCL/guppylang/compare/guppylang-internals-v0.21.0...guppylang-internals-v0.21.1) (2025-08-05)
 
 

{guppylang_internals-0.21.1 → guppylang_internals-0.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guppylang-internals
-Version: 0.21.1
+Version: 0.22.0
 Summary: Compiler internals for `guppylang` package.
 Author-email: Mark Koch <mark.koch@quantinuum.com>, TKET development team <tket-support@quantinuum.com>
 Maintainer-email: Mark Koch <mark.koch@quantinuum.com>, TKET development team <tket-support@quantinuum.com>

{guppylang_internals-0.21.1 → guppylang_internals-0.22.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "guppylang-internals"
-version = "0.21.1"
+version = "0.22.0"
 requires-python = ">=3.10,<4"
 description = "Compiler internals for `guppylang` package."
 license = { file = "LICENCE" }

{guppylang_internals-0.21.1 → guppylang_internals-0.22.0}/src/guppylang_internals/__init__.py

@@ -1,3 +1,3 @@
 # This is updated by our release-please workflow, triggered by this
 # annotation: x-release-please-version
-__version__ = "0.21.1"
+__version__ = "0.22.0"

{guppylang_internals-0.21.1 → guppylang_internals-0.22.0}/src/guppylang_internals/ast_util.py

@@ -131,7 +131,10 @@ class ContextAdjuster(ast.NodeTransformer):
     def visit_Name(self, node: ast.Name) -> ast.Name:
         return with_loc(node, ast.Name(id=node.id, ctx=self.ctx))
 
-    def visit_Starred(self, node: ast.Starred) -> ast.Starred:
+    def visit_Starred(
+        self,
+        node: ast.Starred,
+    ) -> ast.Starred:
         return with_loc(node, ast.Starred(value=self.visit(node.value), ctx=self.ctx))
 
     def visit_Tuple(self, node: ast.Tuple) -> ast.Tuple:
@@ -234,7 +237,11 @@ def set_location_from(node: ast.AST, loc: ast.AST) -> None:
 
 
 def annotate_location(
-    node: ast.AST, source: str, file: str, line_offset: int, recurse: bool = True
+    node: ast.AST,
+    source: str,
+    file: str,
+    line_offset: int,
+    recurse: bool = True,
 ) -> None:
     node.line_offset = line_offset  # type: ignore[attr-defined]
     node.file = file  # type: ignore[attr-defined]

{guppylang_internals-0.21.1 → guppylang_internals-0.22.0}/src/guppylang_internals/checker/stmt_checker.py

@@ -54,6 +54,7 @@ from guppylang_internals.checker.expr_checker import (
 from guppylang_internals.error import GuppyError, GuppyTypeError, InternalGuppyError
 from guppylang_internals.nodes import (
     AnyUnpack,
+    ArrayUnpack,
     DesugaredArrayComp,
     IterableUnpack,
     MakeIter,
@@ -65,6 +66,7 @@ from guppylang_internals.nodes import (
 from guppylang_internals.span import Span, to_span
 from guppylang_internals.tys.builtin import (
     array_type,
+    get_array_length,
     get_element_type,
     get_iter_size,
     is_array_type,
@@ -260,8 +262,10 @@ class StmtChecker(AstVisitor[BBStatement]):
             assert all_equal(starred_tys)
             if starred_tys:
                 starred_ty, *_ = starred_tys
-            # Starred part could be empty. If it's an iterable unpack, we're still fine
-            # since we know the yielded type
+            # Starred part could be empty. If it's an array or iterable unpack, we're
+            # still fine since we know the yielded type
+            elif isinstance(unpack, ArrayUnpack):
+                starred_ty = unpack.elt_type
             elif isinstance(unpack, IterableUnpack):
                 starred_ty = unpack.compr.elt_ty
             # For tuple unpacks, there is no way to infer a type for the empty starred
@@ -304,6 +308,19 @@ class StmtChecker(AstVisitor[BBStatement]):
             elts = expr.elts if isinstance(expr, ast.Tuple) else [expr] * len(tys)
             return TupleUnpack(pattern), elts, tys
 
+        elif is_array_type(ty):
+            match get_array_length(ty):
+                case ConstValue(value=int(size)):
+                    elt_ty = get_element_type(ty)
+                    unpack = ArrayUnpack(pattern, size, elt_ty)
+                    return unpack, size * [expr], size * [elt_ty]
+                case generic_size:
+                    err = UnpackableError(expr, get_type(expr))
+                    err.add_sub_diagnostic(
+                        UnpackableError.GenericSize(None, generic_size)
+                    )
+                    raise GuppyError(err)
+
         elif self.ctx.globals.get_instance_func(ty, "__iter__"):
             size = check_iter_unpack_has_static_size(expr, self.ctx)
             # Create a dummy variable and assign the expression to it. This helps us to

{guppylang_internals-0.21.1 → guppylang_internals-0.22.0}/src/guppylang_internals/compiler/core.py

@@ -8,12 +8,14 @@ from typing import TYPE_CHECKING, Any, ClassVar, cast
 
 import tket_exts
 from hugr import Hugr, Node, Wire, ops
+from hugr import ext as he
 from hugr import tys as ht
 from hugr.build import function as hf
 from hugr.build.dfg import DP, DefinitionBuilder, DfBase
 from hugr.hugr.base import OpVarCov
 from hugr.hugr.node_port import ToNode
 from hugr.std import PRELUDE
+from hugr.std.collections.array import EXTENSION as ARRAY_EXTENSION
 from typing_extensions import assert_never
 
 from guppylang_internals.checker.core import (
@@ -36,6 +38,7 @@ from guppylang_internals.definition.value import CompiledCallableDef
 from guppylang_internals.diagnostic import Error
 from guppylang_internals.engine import ENGINE
 from guppylang_internals.error import GuppyError, InternalGuppyError
+from guppylang_internals.std._internal.compiler.tket_exts import GUPPY_EXTENSION
 from guppylang_internals.tys.arg import ConstArg, TypeArg
 from guppylang_internals.tys.builtin import nat_type
 from guppylang_internals.tys.common import ToHugrContext
@@ -114,7 +117,7 @@ class EntryMonomorphizeError(Error):
     title: ClassVar[str] = "Invalid entry point"
     span_label: ClassVar[str] = (
         "Function `{name}` is not a valid compilation entry point since the value of "
-        "generic paramater `{param}` is not known"
+        "generic parameter `{param}` is not known"
     )
     name: str
     param: Parameter
@@ -242,6 +245,11 @@ class CompilerContext(ToHugrContext):
             with track_hugr_side_effects(), self.set_monomorphized_args(mono_args):
                 next_def.compile_inner(self)
 
+        # Insert explicit drops for affine types
+        # TODO: This is a quick workaround until we can properly insert these drops
+        #   during linearity checking. See https://github.com/CQCL/guppylang/issues/1082
+        insert_drops(self.module.hugr)
+
         return entry_compiled
 
     def build_compiled_instance_func(
@@ -611,3 +619,78 @@ def track_hugr_side_effects() -> Iterator[None]:
         yield
     finally:
         Hugr.add_node = hugr_add_node  # type: ignore[method-assign]
+
+
+def qualified_name(type_def: he.TypeDef) -> str:
+    """Returns the qualified name of a Hugr extension type.
+    TODO: Remove once upstreamed, see https://github.com/CQCL/hugr/issues/2426
+    """
+    if type_def._extension is not None:
+        return f"{type_def._extension.name}.{type_def.name}"
+    return type_def.name
+
+
+#: List of linear extension types that correspond to affine Guppy types and thus require
+#: insertion of an explicit drop operation.
+AFFINE_EXTENSION_TYS: list[str] = [
+    qualified_name(ARRAY_EXTENSION.get_type("array")),
+]
+
+
+def requires_drop(ty: ht.Type) -> bool:
+    """Checks if a Hugr type requires an implicit drop op insertion.
+    This is the case for linear Hugr types that correspond to affine Guppy types, or
+    any other type containing one of those. See `AFFINE_EXTENSION_TYS`.
+    """
+    match ty:
+        case ht.ExtType(type_def=type_def, args=args):
+            return qualified_name(type_def) in AFFINE_EXTENSION_TYS or any(
+                requires_drop(arg.ty) for arg in args if isinstance(arg, ht.TypeTypeArg)
+            )
+        case ht.Opaque(id=name, extension=extension, args=args):
+            qualified = f"{extension}.{name}" if extension else name
+            return qualified in AFFINE_EXTENSION_TYS or any(
+                requires_drop(arg.ty) for arg in args if isinstance(arg, ht.TypeTypeArg)
+            )
+        case ht.Sum(variant_rows=rows):
+            return any(requires_drop(ty) for row in rows for ty in row)
+        case ht.Variable(bound=bound):
+            return bound == ht.TypeBound.Linear
+        case ht.FunctionType():
+            return False
+        case ht.Alias():
+            raise InternalGuppyError("Alias should not be emitted!")
+        case _:
+            return False
+
+
+def drop_op(ty: ht.Type) -> ops.ExtOp:
+    """Returns the operation to drop affine values."""
+    return GUPPY_EXTENSION.get_op("drop").instantiate(
+        [ht.TypeTypeArg(ty)], ht.FunctionType([ty], [])
+    )
+
+
+def insert_drops(hugr: Hugr[OpVarCov]) -> None:
+    """Inserts explicit drop ops for unconnected ports into the Hugr.
+    TODO: This is a quick workaround until we can properly insert these drops during
+      linearity checking. See https://github.com/CQCL/guppylang/issues/1082
+    """
+    for node in hugr:
+        data = hugr[node]
+        # Iterating over `node.outputs()` doesn't work reliably since it sometimes
+        # raises an `IncompleteOp` exception. Instead, we query the number of out ports
+        # and look them up by index. However, this method is *also* broken when
+        # isnpecting `FuncDefn` nodes due to https://github.com/CQCL/hugr/issues/2438.
+        if isinstance(data.op, ops.FuncDefn):
+            continue
+        for i in range(hugr.num_out_ports(node)):
+            port = node.out(i)
+            kind = hugr.port_kind(port)
+            if (
+                next(iter(hugr.linked_ports(port)), None) is None
+                and isinstance(kind, ht.ValueKind)
+                and requires_drop(kind.ty)
+            ):
+                drop = hugr.add_node(drop_op(kind.ty), parent=data.parent)
+                hugr.add_link(port, drop.inp(0))

{guppylang_internals-0.21.1 → guppylang_internals-0.22.0}/src/guppylang_internals/compiler/stmt_compiler.py

@@ -17,6 +17,7 @@ from guppylang_internals.compiler.core import (
 from guppylang_internals.compiler.expr_compiler import ExprCompiler
 from guppylang_internals.error import InternalGuppyError
 from guppylang_internals.nodes import (
+    ArrayUnpack,
     CheckedNestedFunctionDef,
     IterableUnpack,
     PlaceNode,
@@ -124,15 +125,12 @@ class StmtCompiler(CompilerBase, AstVisitor[None]):
             self._assign(starred, array)
 
     @_assign.register
-    def _assign_iterable(self, lhs: IterableUnpack, port: Wire) -> None:
-        """Handles assignment where the RHS is an iterable that should be unpacked."""
-        # Given an assignment pattern `left, *starred, right`, collect the RHS into an
-        # array and pop from the left and right, leaving us with the starred array in
-        # the middle
-        assert isinstance(lhs.compr.length, ConstValue)
-        length = lhs.compr.length.value
-        assert isinstance(length, int)
-        opt_elt_ty = ht.Option(lhs.compr.elt_ty.to_hugr(self.ctx))
+    def _assign_array(self, lhs: ArrayUnpack, port: Wire) -> None:
+        """Handles assignment where the RHS is an array that should be unpacked."""
+        # Given an assignment pattern `left, *starred, right`, pop from the left and
+        # right, leaving us with the starred array in the middle
+        length = lhs.length
+        opt_elt_ty = ht.Option(lhs.elt_type.to_hugr(self.ctx))
 
         def pop(
             array: Wire, length: int, pats: list[ast.expr], from_left: bool
@@ -159,8 +157,7 @@ class StmtCompiler(CompilerBase, AstVisitor[None]):
                 self._assign(pat, elt)
             return array, length - num_pats
 
-        self.dfg[lhs.rhs_var.place] = port
-        array = self.expr_compiler.visit_DesugaredArrayComp(lhs.compr)
+        array = port
         array, length = pop(array, length, lhs.pattern.left, True)
         array, length = pop(array, length, lhs.pattern.right, False)
         if lhs.pattern.starred:
@@ -169,6 +166,20 @@ class StmtCompiler(CompilerBase, AstVisitor[None]):
             assert length == 0
             self.builder.add_op(array_discard_empty(opt_elt_ty), array)
 
+    @_assign.register
+    def _assign_iterable(self, lhs: IterableUnpack, port: Wire) -> None:
+        """Handles assignment where the RHS is an iterable that should be unpacked."""
+        # Collect the RHS into an array by building the comprehension and then fall back
+        # to the array case above
+        assert isinstance(lhs.compr.length, ConstValue)
+        length = lhs.compr.length.value
+        assert isinstance(length, int)
+
+        self.dfg[lhs.rhs_var.place] = port
+        array = self.expr_compiler.visit_DesugaredArrayComp(lhs.compr)
+        unpack = ArrayUnpack(lhs.pattern, length, lhs.compr.elt_ty)
+        self._assign_array(unpack, array)
+
     def visit_Assign(self, node: ast.Assign) -> None:
         [target] = node.targets
         port = self.expr_compiler.compile(node.value, self.dfg)

{guppylang_internals-0.21.1 → guppylang_internals-0.22.0}/src/guppylang_internals/definition/pytket_circuits.py

@@ -7,6 +7,7 @@ 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 guppylang_internals.ast_util import AstNode, has_empty_body, with_loc
 from guppylang_internals.checker.core import Context, Globals
@@ -37,17 +38,17 @@ from guppylang_internals.definition.value import (
     CompiledCallableDef,
     CompiledHugrNodeDef,
 )
+from guppylang_internals.engine import ENGINE
 from guppylang_internals.error import GuppyError, InternalGuppyError
 from guppylang_internals.nodes import GlobalCall
 from guppylang_internals.span import SourceMap, Span, ToSpan
 from guppylang_internals.std._internal.compiler.array import (
-    array_discard_empty,
     array_new,
-    array_pop,
+    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
+from guppylang_internals.tys.builtin import array_type, bool_type, float_type
 from guppylang_internals.tys.subst import Inst, Subst
 from guppylang_internals.tys.ty import (
     FuncInput,
@@ -87,9 +88,7 @@ class RawPytketDef(ParsableDef):
         stub_signature = check_signature(func_ast, globals)
 
         # Compare signatures.
-        circuit_signature = _signature_from_circuit(
-            self.input_circuit, globals, self.defined_at
-        )
+        circuit_signature = _signature_from_circuit(self.input_circuit, self.defined_at)
         if not (
             circuit_signature.inputs == stub_signature.inputs
             and circuit_signature.output == stub_signature.output
@@ -126,7 +125,7 @@ class RawLoadPytketDef(ParsableDef):
     def parse(self, globals: Globals, sources: SourceMap) -> "ParsedPytketDef":
         """Creates a function signature based on the user-provided circuit."""
         circuit_signature = _signature_from_circuit(
-            self.input_circuit, globals, self.source_span, self.use_arrays
+            self.input_circuit, self.source_span, self.use_arrays
         )
 
         return ParsedPytketDef(
@@ -174,6 +173,7 @@ class ParsedPytketDef(CallableDef, CompilableDef):
                 circ = envelope.read_envelope(
                     Tk2Circuit(self.input_circuit).to_bytes(EnvelopeConfig.TEXT)
                 ).modules[0]
+
                 mapping = module.hugr.insert_hugr(circ)
                 hugr_func = mapping[circ.entrypoint]
 
@@ -182,47 +182,87 @@ class ParsedPytketDef(CallableDef, CompilableDef):
                     self.name, func_type.body.input, func_type.body.output
                 )
 
-                # Initialise every input bit in the circuit as false.
-                # TODO: Provide the option for the user to pass this input as well.
-                bool_wires = [
-                    outer_func.load(val.FALSE) for _ in range(self.input_circuit.n_bits)
-                ]
+                # Number of qubit inputs in the outer function.
+                offset = (
+                    len(self.input_circuit.q_registers)
+                    if self.use_arrays
+                    else self.input_circuit.n_qubits
+                )
 
-                input_list = []
+                input_list: list[Wire] = []
                 if self.use_arrays:
                     # If the input is given as arrays, we need to unpack each element in
                     # them into separate wires.
-                    # TODO: Replace with actual unpack HUGR op once
-                    # https://github.com/CQCL/hugr/issues/1947 is done.
-                    def unpack(
-                        array: Wire, elem_ty: ht.Type, length: int
-                    ) -> list[Wire]:
-                        err = "Internal error: unpacking of array failed"
-                        elts: list[Wire] = []
-                        for i in range(length):
-                            res = outer_func.add_op(
-                                array_pop(elem_ty, length - i, True), array
+                    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 = [
+                            build_unwrap(
+                                outer_func,
+                                opt_elem,
+                                "Internal error: unwrapping of array element failed",
                             )
-                            [elt_opt, array] = build_unwrap(outer_func, res, err)
-                            [elt] = build_unwrap(outer_func, elt_opt, err)
-                            elts.append(elt)
-                        outer_func.add_op(array_discard_empty(elem_ty), array)
-                        return elts
-
-                    # Must be same length due to earlier signature computation /
-                    # comparison.
-                    for q_reg, wire in zip(
-                        self.input_circuit.q_registers,
-                        list(outer_func.inputs()),
-                        strict=True,
-                    ):
-                        input_list.extend(unpack(wire, ht.Option(ht.Qubit), q_reg.size))
+                            for opt_elem in opt_elem_wires
+                        ]
+                        input_list.extend(elem_wires)
 
                 else:
                     # Otherwise pass inputs directly.
-                    input_list = list(outer_func.inputs())
+                    input_list = list(outer_func.inputs()[:offset])
 
-                call_node = outer_func.call(hugr_func, *(input_list + bool_wires))
+                # Initialise every input bit in the circuit as false.
+                # TODO: Provide the option for the user to pass this input as well.
+                bool_wires = [
+                    outer_func.load(val.FALSE) for _ in range(self.input_circuit.n_bits)
+                ]
+
+                # Symbolic parameters (if present) get passed after qubits and bools.
+                has_params = len(self.input_circuit.free_symbols()) != 0
+                if has_params and "TKET1.input_parameters" not in hugr_func.metadata:
+                    raise InternalGuppyError(
+                        "Parameter metadata is missing from pytket circuit HUGR"
+                    ) from None
+                param_wires: list[Wire] = []
+                # We assume they are given in lexicographic order by the user, then we
+                # wire them up according to the metadata order.
+                if has_params:
+                    lex_params: list[Wire] = list(outer_func.inputs()[offset:])
+                    if self.use_arrays:
+                        opt_param_wires = outer_func.add_op(
+                            array_unpack(
+                                ht.Option(ht.Tuple(float_type().to_hugr(ctx))),
+                                q_reg.size,
+                            ),
+                            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
+                        ]
+                    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.
+                    for angle in angle_wires:
+                        [halfturns] = outer_func.add_op(
+                            ops.UnpackTuple([FLOAT_T]), angle
+                        )
+                        param_wires.append(halfturns)
+
+                # Pass all arguments to call node.
+                call_node = outer_func.call(
+                    hugr_func, *(input_list + bool_wires + param_wires)
+                )
 
                 # Pytket circuit hugr has qubit and bool wires in the opposite
                 # order to Guppy output wires.
@@ -354,7 +394,6 @@ class CompiledPytketDef(ParsedPytketDef, CompiledCallableDef, CompiledHugrNodeDe
 
 def _signature_from_circuit(
     input_circuit: Any,
-    globals: Globals,
     defined_at: ToSpan | None,
     use_arrays: bool = False,
 ) -> FunctionType:
@@ -367,16 +406,28 @@ def _signature_from_circuit(
                 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
@@ -386,9 +437,13 @@ def _signature_from_circuit(
                         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,
+                        [FuncInput(qubit_ty, InputFlags.Inout)] * input_circuit.n_qubits
+                        + param_inputs,
                         row_to_type([bool_type()] * input_circuit.n_bits),
                     )
             except ImportError:

{guppylang_internals-0.21.1 → guppylang_internals-0.22.0}/src/guppylang_internals/nodes.py

@@ -363,6 +363,26 @@ class TupleUnpack(ast.expr):
     _fields = ("pattern",)
 
 
+class ArrayUnpack(ast.expr):
+    """The LHS of an unpacking assignment of an array."""
+
+    #: The (possibly starred) unpacking pattern
+    pattern: UnpackPattern
+
+    #: Length of the array
+    length: int
+
+    #: Element type of the array
+    elt_type: Type
+
+    _fields = ("pattern",)
+
+    def __init__(self, pattern: UnpackPattern, length: int, elt_type: Type) -> None:
+        super().__init__(pattern)
+        self.length = length
+        self.elt_type = elt_type
+
+
 class IterableUnpack(ast.expr):
     """The LHS of an unpacking assignment of an iterable type."""
 
@@ -388,7 +408,7 @@ class IterableUnpack(ast.expr):
 
 
 #: Any unpacking operation.
-AnyUnpack = TupleUnpack | IterableUnpack
+AnyUnpack = TupleUnpack | ArrayUnpack | IterableUnpack
 
 
 class NestedFunctionDef(ast.FunctionDef):

{guppylang_internals-0.21.1 → guppylang_internals-0.22.0}/src/guppylang_internals/std/_internal/checker.py

@@ -1,10 +1,10 @@
 import ast
 from dataclasses import dataclass
-from typing import ClassVar, cast
+from typing import ClassVar
 
 from typing_extensions import assert_never
 
-from guppylang_internals.ast_util import get_type, with_loc, with_type
+from guppylang_internals.ast_util import get_type, with_loc
 from guppylang_internals.checker.core import ComptimeVariable, Context
 from guppylang_internals.checker.errors.generic import ExpectedError, UnsupportedError
 from guppylang_internals.checker.errors.type_errors import (
@@ -23,7 +23,6 @@ from guppylang_internals.checker.expr_checker import (
 from guppylang_internals.definition.custom import (
     CustomCallChecker,
 )
-from guppylang_internals.definition.struct import CheckedStructDef, RawStructDef
 from guppylang_internals.diagnostic import Error, Note
 from guppylang_internals.error import GuppyError, GuppyTypeError, InternalGuppyError
 from guppylang_internals.nodes import (
@@ -31,7 +30,6 @@ from guppylang_internals.nodes import (
     DesugaredArrayComp,
     DesugaredGeneratorExpr,
     ExitKind,
-    GenericParamValue,
     GlobalCall,
     MakeIter,
     PanicExpr,
@@ -61,7 +59,6 @@ from guppylang_internals.tys.ty import (
     InputFlags,
     NoneType,
     NumericType,
-    StructType,
     Type,
     unify,
 )
@@ -495,45 +492,6 @@ class ExitChecker(CustomCallChecker):
         return expr, {}
 
 
-class RangeChecker(CustomCallChecker):
-    """Call checker for the `range` function."""
-
-    def synthesize(self, args: list[ast.expr]) -> tuple[ast.expr, Type]:
-        check_num_args(1, len(args), self.node)
-        [stop] = args
-        stop_checked, _ = ExprChecker(self.ctx).check(stop, int_type(), "argument")
-        range_iter, range_ty = self.make_range(stop_checked)
-        # Check if `stop` is a statically known value. Note that we need to do this on
-        # the original `stop` instead of `stop_checked` to avoid any previously inserted
-        # `int` coercions.
-        if (static_stop := self.check_static(stop)) is not None:
-            return to_sized_iter(range_iter, range_ty, static_stop, self.ctx)
-        return range_iter, range_ty
-
-    def check_static(self, stop: ast.expr) -> "int | Const | None":
-        stop, _ = ExprSynthesizer(self.ctx).synthesize(stop, allow_free_vars=True)
-        if isinstance(stop, ast.Constant) and isinstance(stop.value, int):
-            return stop.value
-        if isinstance(stop, GenericParamValue) and stop.param.ty == nat_type():
-            return stop.param.to_bound().const
-        return None
-
-    def range_ty(self) -> StructType:
-        from guppylang.std.builtins import Range
-        from guppylang_internals.engine import ENGINE
-
-        def_id = cast(RawStructDef, Range).id
-        range_type_def = ENGINE.get_checked(def_id)
-        assert isinstance(range_type_def, CheckedStructDef)
-        return StructType([], range_type_def)
-
-    def make_range(self, stop: ast.expr) -> tuple[ast.expr, Type]:
-        make_range = self.ctx.globals.get_instance_func(self.range_ty(), "__new__")
-        assert make_range is not None
-        start = with_type(int_type(), with_loc(self.node, ast.Constant(value=0)))
-        return make_range.synthesize_call([start, stop], self.node, self.ctx)
-
-
 def to_sized_iter(
     iterator: ast.expr, range_ty: Type, size: "int | Const", ctx: Context
 ) -> tuple[ast.expr, Type]:

{guppylang_internals-0.21.1 → guppylang_internals-0.22.0}/src/guppylang_internals/std/_internal/compiler/tket_exts.py

@@ -4,6 +4,7 @@ from hugr import val
 from tket_exts import (
     debug,
     futures,
+    guppy,
     opaque_bool,
     qsystem,
     qsystem_random,
@@ -17,6 +18,7 @@ from tket_exts import (
 BOOL_EXTENSION = opaque_bool()
 DEBUG_EXTENSION = debug()
 FUTURES_EXTENSION = futures()
+GUPPY_EXTENSION = guppy()
 QSYSTEM_EXTENSION = qsystem()
 QSYSTEM_RANDOM_EXTENSION = qsystem_random()
 QSYSTEM_UTILS_EXTENSION = qsystem_utils()
@@ -29,6 +31,7 @@ TKET_EXTENSIONS = [
     BOOL_EXTENSION,
     DEBUG_EXTENSION,
     FUTURES_EXTENSION,
+    GUPPY_EXTENSION,
     QSYSTEM_EXTENSION,
     QSYSTEM_RANDOM_EXTENSION,
     QSYSTEM_UTILS_EXTENSION,

{guppylang_internals-0.21.1 → guppylang_internals-0.22.0}/src/guppylang_internals/tracing/builtins_mock.py

@@ -7,7 +7,8 @@ the builtins to avoid raising the `TypeError` in that case.
 """
 
 import builtins
-from collections.abc import Callable
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager
 from typing import Any
 
 from guppylang_internals.tracing.object import GuppyObject, GuppyStructObject
@@ -46,10 +47,10 @@ class float(builtins.float, metaclass=_mock_meta(builtins.float)):  # type: igno
 
 
 class int(builtins.int, metaclass=_mock_meta(builtins.int)):  # type: ignore[misc]
-    def __new__(cls, x: Any = 0, /, **kwargs: Any) -> Any:
+    def __new__(cls, x: Any = 0, /, *args: Any, **kwargs: Any) -> Any:
         if isinstance(x, GuppyObject):
-            return x.__int__(**kwargs)
-        return builtins.int(x, **kwargs)
+            return x.__int__(*args, **kwargs)
+        return builtins.int(x, *args, **kwargs)
 
 
 def len(x: Any) -> Any:
@@ -58,5 +59,22 @@ def len(x: Any) -> Any:
     return builtins.len(x)
 
 
-def mock_builtins(f: Callable[..., Any]) -> None:
-    f.__globals__.update({"float": float, "int": int, "len": len})
+@contextmanager
+def mock_builtins(f: Callable[..., Any]) -> Iterator[None]:
+    # References to builtins inside `f` are looked up in `f.__builtins__`.
+    # Unfortunately, this is a readonly attribute so we can't assign a new dict to it.
+    # Mutating in-place is also a bad idea since this would also mutate the `builtins`
+    # module, making us loose an escape hatch to query the original. Instead, let's
+    # mutate `f.__globals__` which makes Python believe that the builtins are shadowed.
+    mock = {"float": float, "int": int, "len": len}
+    old = {x: f.__globals__[x] for x in mock if x in f.__globals__}
+    f.__globals__.update(mock)
+    try:
+        yield
+    finally:
+        # Reset back to the prior state since mutating `f.__globals__` also mutated the
+        # outer globals
+        for x in mock:
+            if x not in old:
+                del f.__globals__[x]
+        f.__globals__.update(old)

{guppylang_internals-0.21.1 → guppylang_internals-0.22.0}/src/guppylang_internals/tracing/function.py

@@ -70,8 +70,7 @@ def trace_function(
             for wire, inp in zip(builder.inputs(), ty.inputs, strict=True)
         ]
 
-        with exception_hook(tracing_except_hook):
-            mock_builtins(python_func)
+        with exception_hook(tracing_except_hook), mock_builtins(python_func):
             py_out = python_func(*inputs)
 
         try: