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

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.26.0"
+__version__ = "0.27.0"

guppylang_internals/cfg/builder.py

@@ -668,6 +668,9 @@ def is_comptime_expression(node: ast.AST) -> ComptimeExpr | None:
 
     Otherwise, returns `None`.
     """
+    if isinstance(node, ComptimeExpr):
+        return node
+
     if (
         isinstance(node, ast.Call)
         and isinstance(node.func, ast.Name)

guppylang_internals/checker/errors/linearity.py

@@ -33,7 +33,9 @@ class AlreadyUsedError(Error):
 
     @dataclass(frozen=True)
     class PrevUse(Note):
-        span_label: ClassVar[str] = "since it was already {prev_kind.subjunctive} here"
+        span_label: ClassVar[str] = (
+            "{place.describe} already {prev_kind.subjunctive} here"
+        )
         prev_kind: UseKind
 
     @dataclass(frozen=True)
@@ -55,7 +57,9 @@ class ComprAlreadyUsedError(Error):
 
     @dataclass(frozen=True)
     class PrevUse(Note):
-        span_label: ClassVar[str] = "since it was already {prev_kind.subjunctive} here"
+        span_label: ClassVar[str] = (
+            "{place.describe} already {prev_kind.subjunctive} here"
+        )
         prev_kind: UseKind
 
 

guppylang_internals/checker/expr_checker.py

@@ -85,6 +85,7 @@ from guppylang_internals.checker.errors.type_errors import (
     WrongNumberOfArgsError,
 )
 from guppylang_internals.definition.common import Definition
+from guppylang_internals.definition.parameter import ParamDef
 from guppylang_internals.definition.ty import TypeDef
 from guppylang_internals.definition.value import CallableDef, ValueDef
 from guppylang_internals.error import (
@@ -407,23 +408,27 @@ class ExprSynthesizer(AstVisitor[tuple[ast.expr, Type]]):
             raise GuppyError(IllegalConstant(node, type(node.value)))
         return node, ty
 
+    def _check_generic_param(self, name: str, node: ast.expr) -> tuple[ast.expr, Type]:
+        """Helper method to check a generic parameter (ConstParam or TypeParam)."""
+        param = self.ctx.generic_params[name]
+        match param:
+            case ConstParam() as param:
+                ast_node = with_loc(node, GenericParamValue(id=name, param=param))
+                return ast_node, param.ty
+            case TypeParam() as param:
+                raise GuppyError(
+                    ExpectedError(node, "a value", got=f"type `{param.name}`")
+                )
+            case _:
+                return assert_never(param)
+
     def visit_Name(self, node: ast.Name) -> tuple[ast.expr, Type]:
         x = node.id
         if x in self.ctx.locals:
             var = self.ctx.locals[x]
             return with_loc(node, PlaceNode(place=var)), var.ty
         elif x in self.ctx.generic_params:
-            param = self.ctx.generic_params[x]
-            match param:
-                case ConstParam() as param:
-                    ast_node = with_loc(node, GenericParamValue(id=x, param=param))
-                    return ast_node, param.ty
-                case TypeParam() as param:
-                    raise GuppyError(
-                        ExpectedError(node, "a value", got=f"type `{param.name}`")
-                    )
-                case _:
-                    return assert_never(param)
+            return self._check_generic_param(x, node)
         elif x in self.ctx.globals:
             match self.ctx.globals[x]:
                 case Definition() as defn:
@@ -454,6 +459,16 @@ class ExprSynthesizer(AstVisitor[tuple[ast.expr, Type]]):
                 defn, "__new__"
             ):
                 return with_loc(node, GlobalName(id=name, def_id=constr.id)), constr.ty
+            # Handle parameter definitions (e.g., nat_var) that may be imported
+            case ParamDef():
+                # Check if this parameter is in our generic_params
+                # (e.g., used in type signature)
+                if name in self.ctx.generic_params:
+                    return self._check_generic_param(name, node)
+                # If not in generic_params, it's being used outside its scope
+                raise GuppyError(
+                    ExpectedError(node, "a value", got=f"{defn.description} `{name}`")
+                )
             case defn:
                 raise GuppyError(
                     ExpectedError(node, "a value", got=f"{defn.description} `{name}`")

guppylang_internals/compiler/expr_compiler.py

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

@@ -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,
@@ -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/function.py

@@ -33,6 +33,7 @@ from guppylang_internals.definition.common import (
     ParsableDef,
     UnknownSourceError,
 )
+from guppylang_internals.definition.metadata import GuppyMetadata, add_metadata
 from guppylang_internals.definition.value import (
     CallableDef,
     CallReturnWires,
@@ -72,13 +73,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 +113,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 +126,7 @@ class ParsedFunctionDef(CheckableDef, CallableDef):
             self.ty,
             self.docstring,
             cfg,
+            metadata=self.metadata,
         )
 
     def check_call(
@@ -177,7 +190,11 @@ class CheckedFunctionDef(ParsedFunctionDef, MonomorphizableDef):
         func_def = module.module_root_builder().define_function(
             self.name, hugr_ty.body.input, hugr_ty.body.output, hugr_ty.params
         )
-        add_unitarity_metadata(func_def, self.ty.unitary_flags)
+        add_metadata(
+            func_def,
+            self.metadata,
+            additional_metadata={"unitary": self.ty.unitary_flags.value},
+        )
         return CompiledFunctionDef(
             self.id,
             self.name,
@@ -187,6 +204,7 @@ class CheckedFunctionDef(ParsedFunctionDef, MonomorphizableDef):
             self.docstring,
             self.cfg,
             func_def,
+            metadata=self.metadata,
         )
 
 
@@ -305,8 +323,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)}
+
+
+@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

@@ -46,6 +46,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
@@ -235,12 +236,15 @@ class ParsedPytketDef(CallableDef, CompilableDef):
                     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(

guppylang_internals/diagnostic.py

@@ -208,7 +208,8 @@ class DiagnosticsRenderer:
     MAX_MESSAGE_LINE_LEN: Final[int] = 80
 
     #: Number of preceding source lines we show to give additional context
-    PREFIX_CONTEXT_LINES: Final[int] = 2
+    PREFIX_ERROR_CONTEXT_LINES: Final[int] = 2
+    PREFIX_NOTE_CONTEXT_LINES: Final[int] = 1
 
     def __init__(self, source: SourceMap) -> None:
         self.buffer = []
@@ -243,31 +244,84 @@ class DiagnosticsRenderer:
         else:
             span = to_span(diag.span)
             level = self.level_str(diag.level)
-            all_spans = [span] + [
-                to_span(child.span) for child in diag.children if child.span
+
+            children_with_span = [
+                (child, to_span(child.span)) for child in diag.children if child.span
             ]
+            all_spans = [span] + [span for _, span in children_with_span]
             max_lineno = max(s.end.line for s in all_spans)
+
             self.buffer.append(f"{level}: {diag.rendered_title} (at {span.start})")
+
+            # Render main error span first
             self.render_snippet(
                 span,
                 diag.rendered_span_label,
                 max_lineno,
                 is_primary=True,
-                prefix_lines=self.PREFIX_CONTEXT_LINES,
+                prefix_lines=self.PREFIX_ERROR_CONTEXT_LINES,
             )
-            # First render all sub-diagnostics that come with a span
-            for sub_diag in diag.children:
-                if sub_diag.span:
+
+            match children_with_span:
+                case []:
+                    pass
+                case [(only_child, span)]:
+                    self.buffer.append("\nNote:")
                     self.render_snippet(
-                        to_span(sub_diag.span),
-                        sub_diag.rendered_span_label,
+                        span,
+                        only_child.rendered_span_label,
                         max_lineno,
-                        is_primary=False,
+                        prefix_lines=self.PREFIX_NOTE_CONTEXT_LINES,
+                        print_pad_line=True,
                     )
+                case [(first_child, first_span), *children_with_span]:
+                    self.buffer.append("\nNotes:")
+                    self.render_snippet(
+                        first_span,
+                        first_child.rendered_span_label,
+                        max_lineno,
+                        prefix_lines=self.PREFIX_NOTE_CONTEXT_LINES,
+                        print_pad_line=True,
+                    )
+
+                    prev_span_end_lineno = first_span.end.line
+
+                    for sub_diag, span in children_with_span:
+                        span_start_lineno = span.start.line
+                        span_end_lineno = span.end.line
+
+                        # If notes are on the same line, render them together
+                        if span_start_lineno == prev_span_end_lineno:
+                            prefix_lines = 0
+                            print_pad_line = True
+                        # if notes are close enough, render them adjacently
+                        elif (
+                            span_start_lineno - self.PREFIX_NOTE_CONTEXT_LINES
+                            <= prev_span_end_lineno + 1
+                        ):
+                            prefix_lines = span_start_lineno - prev_span_end_lineno - 1
+                            print_pad_line = False
+                        # otherwise we render a separator between notes
+                        else:
+                            self.buffer.append("")
+                            prefix_lines = self.PREFIX_NOTE_CONTEXT_LINES
+                            print_pad_line = False
+
+                        self.render_snippet(
+                            span,
+                            sub_diag.rendered_span_label,
+                            max_lineno,
+                            prefix_lines=prefix_lines,
+                            print_pad_line=print_pad_line,
+                        )
+                        prev_span_end_lineno = span_end_lineno
+
+            # Render the main diagnostic message if present
             if diag.rendered_message:
                 self.buffer.append("")
                 self.buffer += wrap(diag.rendered_message, self.MAX_MESSAGE_LINE_LEN)
-        # Finally, render all sub-diagnostics that have a non-span message
+
+        # Render all sub-diagnostics that have a non-span message
         for sub_diag in diag.children:
             if sub_diag.rendered_message:
                 self.buffer.append("")
@@ -281,8 +335,9 @@ class DiagnosticsRenderer:
         span: Span,
         label: str | None,
         max_lineno: int,
-        is_primary: bool,
+        is_primary: bool = False,
         prefix_lines: int = 0,
+        print_pad_line: bool = False,
     ) -> None:
         """Renders the source associated with a span together with an optional label.
 
@@ -315,7 +370,8 @@ class DiagnosticsRenderer:
         Optionally includes up to `prefix_lines` preceding source lines to give
         additional context.
         """
-        # Check how much space we need to reserve for the leading line numbers
+        # Check how much horizontal space we need to reserve for the leading
+        # line numbers
         ll_length = len(str(max_lineno))
         highlight_char = "^" if is_primary else "-"
 
@@ -324,8 +380,9 @@ class DiagnosticsRenderer:
             ll = "" if line_number is None else str(line_number)
             self.buffer.append(" " * (ll_length - len(ll)) + ll + " | " + line)
 
-        # One line of padding
-        render_line("")
+        # One line of padding (primary span, first note or between same line notes)
+        if is_primary or print_pad_line:
+            render_line("")
 
         # Grab all lines we want to display and remove excessive leading whitespace
         prefix_lines = min(prefix_lines, span.start.line - 1)

guppylang_internals/engine.py

@@ -220,21 +220,12 @@ class CompilationEngine:
 
         This is the main driver behind `guppy.check()`.
         """
-        from guppylang_internals.checker.core import Globals
-
         # Clear previous compilation cache.
         # TODO: In order to maintain results from the previous `check` call we would
         #  need to store and check if any dependencies have changed.
         self.reset()
 
-        defn = DEF_STORE.raw_defs[id]
-        self.to_check_worklist = {
-            defn.id: (
-                defn.parse(Globals(DEF_STORE.frames[defn.id]), DEF_STORE.sources)
-                if isinstance(defn, ParsableDef)
-                else defn
-            )
-        }
+        self.to_check_worklist[id] = self.get_parsed(id)
         while self.types_to_check_worklist or self.to_check_worklist:
             # Types need to be checked first. This is because parsing e.g. a function
             # definition requires instantiating the types in its signature which can

guppylang_internals/nodes.py

@@ -172,6 +172,14 @@ class MakeIter(ast.expr):
         self.origin_node = origin_node
         self.unwrap_size_hint = unwrap_size_hint
 
+    # Needed for the deepcopy to work correctly, ast.AST's deepcopy logic
+    # reconstructs nodes using _fields only.
+    # If you store extra attributes or rely overwriting the __init__,
+    # deepcopy will crash with a constructor mismatch.
+    # Overriding __reduce__ forces deepcopy to copy the instance dictionary instead
+    __reduce_ex__ = object.__reduce_ex__
+    __reduce__ = object.__reduce__
+
 
 class IterNext(ast.expr):
     """Obtains the next element of an iterator using the `__next__` magic method.
@@ -349,6 +357,10 @@ class ArrayUnpack(ast.expr):
         self.length = length
         self.elt_type = elt_type
 
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class IterableUnpack(ast.expr):
     """The LHS of an unpacking assignment of an iterable type."""
@@ -373,6 +385,10 @@ class IterableUnpack(ast.expr):
         self.compr = compr
         self.rhs_var = rhs_var
 
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 #: Any unpacking operation.
 AnyUnpack = TupleUnpack | ArrayUnpack | IterableUnpack
@@ -420,6 +436,10 @@ class Dagger(ast.expr):
     def __init__(self, node: ast.expr) -> None:
         super().__init__(**node.__dict__)
 
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class Control(ast.Call):
     """The control modifier"""
@@ -434,6 +454,10 @@ class Control(ast.Call):
         self.ctrl = ctrl
         self.qubit_num = None
 
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 class Power(ast.expr):
     """The power modifier"""
@@ -446,6 +470,10 @@ class Power(ast.expr):
         super().__init__(**node.__dict__)
         self.iter = iter
 
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
 
 Modifier = Dagger | Control | Power
 
@@ -533,6 +561,10 @@ class CheckedModifiedBlock(ast.With):
         self.control = control
         self.power = power
 
+    # See MakeIter for explanation
+    __reduce__ = object.__reduce__
+    __reduce_ex__ = object.__reduce_ex__
+
     def __str__(self) -> str:
         # generate a function name from the def_id
         return f"__WithBlock__({self.def_id})"

guppylang_internals/std/_internal/compiler/array.py

@@ -16,6 +16,7 @@ from guppylang_internals.std._internal.compiler.arithmetic import convert_itousi
 from guppylang_internals.std._internal.compiler.prelude import (
     build_unwrap_right,
 )
+from guppylang_internals.std._internal.compiler.tket_bool import make_opaque
 from guppylang_internals.tys.arg import ConstArg, TypeArg
 
 if TYPE_CHECKING:
@@ -206,6 +207,14 @@ def barray_new_all_borrowed(elem_ty: ht.Type, length: ht.TypeArg) -> ops.ExtOp:
     return _instantiate_array_op("new_all_borrowed", elem_ty, length, [], [arr_ty])
 
 
+def barray_is_borrowed(elem_ty: ht.Type, length: ht.TypeArg) -> ops.ExtOp:
+    """Returns an array `is_borrowed` operation."""
+    arr_ty = array_type(elem_ty, length)
+    return _instantiate_array_op(
+        "is_borrowed", elem_ty, length, [arr_ty, ht.USize()], [arr_ty, ht.Bool]
+    )
+
+
 def array_clone(elem_ty: ht.Type, length: ht.TypeArg) -> ops.ExtOp:
     """Returns an array `clone` operation for arrays none of whose elements are
     borrowed."""
@@ -320,7 +329,15 @@ class ArrayGetitemCompiler(ArrayCompiler):
 
 
 class ArraySetitemCompiler(ArrayCompiler):
-    """Compiler for the `array.__setitem__` function."""
+    """Compiler for the `array.__setitem__` function.
+
+    Arguments:
+        elem_first: If `True`, then compiler will assume that the element wire comes
+            before the index wire. Defaults to `False`.
+    """
+
+    def __init__(self, elem_first: bool = False):
+        self.elem_first = elem_first
 
     def _build_classical_setitem(
         self, array: Wire, idx: Wire, elem: Wire
@@ -359,6 +376,8 @@ class ArraySetitemCompiler(ArrayCompiler):
 
     def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
         [array, idx, elem] = args
+        if self.elem_first:
+            elem, idx = idx, elem
         if self.elem_ty.type_bound() == ht.TypeBound.Linear:
             return self._build_linear_setitem(array, idx, elem)
         else:
@@ -379,3 +398,19 @@ class ArrayDiscardAllUsedCompiler(ArrayCompiler):
                 arr,
             )
         return []
+
+
+class ArrayIsBorrowedCompiler(ArrayCompiler):
+    """Compiler for the `array.is_borrowed` method."""
+
+    def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        [array, idx] = args
+        idx = self.builder.add_op(convert_itousize(), idx)
+        array, b = self.builder.add_op(
+            barray_is_borrowed(self.elem_ty, self.length), array, idx
+        )
+        b = self.builder.add_op(make_opaque(), b)
+        return CallReturnWires(regular_returns=[b], inout_returns=[array])
+
+    def compile(self, args: list[Wire]) -> list[Wire]:
+        raise InternalGuppyError("Call compile_with_inouts instead")

guppylang_internals/std/_internal/compiler/either.py

@@ -4,6 +4,8 @@ from collections.abc import Sequence
 from hugr import Wire, ops
 from hugr import tys as ht
 
+from guppylang_internals.ast_util import get_type
+from guppylang_internals.compiler.expr_compiler import pack_returns, unpack_wire
 from guppylang_internals.definition.custom import (
     CustomCallCompiler,
     CustomInoutCallCompiler,
@@ -69,7 +71,14 @@ class EitherConstructor(EitherCompiler, CustomCallCompiler):
             # In the `right` case, the type args are swapped around since `R` occurs
             # first in the signature :(
             ty.variant_rows = [ty.variant_rows[1], ty.variant_rows[0]]
-        return [self.builder.add_op(ops.Tag(self.tag, ty), *args)]
+        # For the same reason, the type of the input corresponds to the first type
+        # variable
+        inp_arg = self.type_args[0]
+        assert isinstance(inp_arg, TypeArg)
+        [inp] = args
+        # Unpack the single input into a row
+        inp_row = unpack_wire(inp, inp_arg.ty, self.builder, self.ctx)
+        return [self.builder.add_op(ops.Tag(self.tag, ty), *inp_row)]
 
 
 class EitherTestCompiler(EitherCompiler):
@@ -128,4 +137,7 @@ class EitherUnwrapCompiler(EitherCompiler, CustomCallCompiler):
             out = build_unwrap_right(
                 self.builder, either, "Either.unwrap_right: value is `left`"
             )
-        return list(out)
+        # Pack outputs into a single wire. We're not allowed to return a row since the
+        # signature has a generic return type (also see `TupleType.preserve`)
+        return_ty = get_type(self.node)
+        return [pack_returns(list(out), return_ty, self.builder, self.ctx)]

guppylang_internals/std/_internal/compiler/tket_bool.py

@@ -40,12 +40,7 @@ class OpaqueBoolVal(hv.ExtensionValue):
     def to_value(self) -> hv.Extension:
         name = "ConstBool"
         payload = self.v
-        return hv.Extension(
-            name,
-            typ=OpaqueBool,
-            val=payload,
-            extensions=[BOOL_EXTENSION.name],
-        )
+        return hv.Extension(name, typ=OpaqueBool, val=payload)
 
     def __str__(self) -> str:
         return f"{self.v}"

guppylang_internals/std/_internal/compiler/tket_exts.py

@@ -59,7 +59,7 @@ class ConstWasmModule(val.ExtensionValue):
 
         name = "ConstWasmModule"
         payload = {"module_filename": self.wasm_file}
-        return val.Extension(name, typ=ty, val=payload, extensions=["tket.wasm"])
+        return val.Extension(name, typ=ty, val=payload)
 
     def __str__(self) -> str:
         return f"tket.wasm.module(module_filename={self.wasm_file})"

guppylang_internals/tracing/object.py

@@ -342,6 +342,10 @@ class GuppyObject(DunderMixin):
         if not ty.droppable and not self._used:
             state.unused_undroppable_objs[self._id] = self
 
+    def __deepcopy__(self, memo: dict[int, Any]) -> "GuppyObject":
+        # Dummy deepcopy implementation, we do not want to actually deepcopy
+        return self
+
     @hide_trace
     def __getattr__(self, key: str) -> Any:  # type: ignore[misc]
         # Guppy objects don't have fields (structs are treated separately below), so the

guppylang_internals/wasm_util.py

@@ -27,7 +27,7 @@ class ConcreteWasmModule:
 class WasmSignatureError(Error):
     title: ClassVar[str] = (
         "Invalid signature for @wasm function `{fn_name}`\n"
-        "in wasm file: `{filename}`"
+        "in wasm file:\n`{filename}`"
     )
     fn_name: str
     filename: str
@@ -53,7 +53,7 @@ class WasmFunctionNotInFile(Error):
 
     @dataclass(frozen=True)
     class WasmFileNote(Note):
-        message: ClassVar[str] = "Wasm file: {filename}"
+        message: ClassVar[str] = "Wasm file:\n`{filename}`"
         filename: str
 
 

{guppylang_internals-0.26.0.dist-info → guppylang_internals-0.27.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guppylang-internals
-Version: 0.26.0
+Version: 0.27.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>
@@ -219,7 +219,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Compilers
 Requires-Python: <4,>=3.10
-Requires-Dist: hugr~=0.14.1
+Requires-Dist: hugr~=0.15.0
 Requires-Dist: tket-exts~=0.12.0
 Requires-Dist: typing-extensions<5,>=4.9.0
 Requires-Dist: wasmtime~=v38.0.0

{guppylang_internals-0.26.0.dist-info → guppylang_internals-0.27.0.dist-info}/RECORD

@@ -1,25 +1,25 @@
-guppylang_internals/__init__.py,sha256=eRNAncl2ENPaWe98y6nNX-U9UtENwgo-yfbWQkZy8Cs,130
+guppylang_internals/__init__.py,sha256=Rr1m2rOvA7MWtjzXW08455-A3GfSprCoMF0CAXJT3ns,130
 guppylang_internals/ast_util.py,sha256=WHa7axpGrdsjzQk3iw3reDzYlcmsx0HsNH4Qbqwjjig,12531
-guppylang_internals/decorator.py,sha256=i0PV3XzWBFjBUBSGfq7d4KmQuEwvM3bAsatcTXVZq98,14112
-guppylang_internals/diagnostic.py,sha256=VCpIhyVD8KPtk0GDYMa8XH0lKVsRbsWNu_ucE2jQT2I,18395
+guppylang_internals/decorator.py,sha256=msdwJjO_xP31qi6Qfsaa4O2ZEuc1ECBcIu_I4TzyGpA,14165
+guppylang_internals/diagnostic.py,sha256=YbfQxuhpvRVnFNJr8PT_ZtCtN1vLW0rFIazUZftmX_U,20875
 guppylang_internals/dummy_decorator.py,sha256=LXTXrdcrr55YzerX3qrHS23q6S9pVdpUAvhprWzKH6E,2330
-guppylang_internals/engine.py,sha256=Npp02xXTb6bFYmHw52LVsVCAUi6dT3qaItEmpCB_2uA,10889
+guppylang_internals/engine.py,sha256=H9wb8KvVyc14GtuPg-U6u1r97w0ezEGNe7VOgJ-EKKg,10607
 guppylang_internals/error.py,sha256=fjHsbglnH9GtcsLF4sSry7FTjrLoiyQ-L1JS3uGirx0,3393
 guppylang_internals/experimental.py,sha256=yERQgpT7P-x0-nr4gU4PdUCntByQwF2I9rfjpWtgqn4,3115
 guppylang_internals/ipython_inspect.py,sha256=rY2DpSpSBrRk0IZmuoz7jh35kGZHQnHLAQQFdb_-WnI,931
-guppylang_internals/nodes.py,sha256=wnnAI3sHZ-OwolcZMKYA_dkmz4IE5Y4CFqXDJ0LXAJM,12824
+guppylang_internals/nodes.py,sha256=rKSEdEgDIFxj2sr1iQqSTOpNElyWvjs_uaeScY3irDY,13901
 guppylang_internals/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guppylang_internals/span.py,sha256=8rWzAAipWunhhyCp44qdUAPmOfAXkEMvicK0PYc3tTg,4986
-guppylang_internals/wasm_util.py,sha256=TyTS9pbFlqpcjCnRwCdCQliGhUWVHkUcZswAytI8oNc,3590
+guppylang_internals/wasm_util.py,sha256=X6a4pZcmMA019Y-FteoSnywpBuBOcZ0wjHy4F8JnS-w,3594
 guppylang_internals/cfg/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guppylang_internals/cfg/analysis.py,sha256=fD3cY0bZ85iNWcmLAXFaXwcdCfB7gzssKjYfsm1J-wQ,8365
 guppylang_internals/cfg/bb.py,sha256=TxV5yHRqiH86lvLR0g4EZ4fs7S6Axoof1l0TIAZArJM,8591
-guppylang_internals/cfg/builder.py,sha256=QqzleSd5-3h77Uy-ng_lNJz73C6-eGwgG_6my8Dh2pQ,28252
+guppylang_internals/cfg/builder.py,sha256=peBarfUK2g2GDtuKOx9dnEFzpZp2LbqUH-gZtNxvJbI,28312
 guppylang_internals/cfg/cfg.py,sha256=qQuWGK1rgPIkMyJFsX3LrqnXp3ptDDOuXwTbgf_NUSE,4489
 guppylang_internals/checker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guppylang_internals/checker/cfg_checker.py,sha256=0hDxw2CTbTbjewtDjaoBehgon17tJaQG9YPO_qR6P0Q,13667
 guppylang_internals/checker/core.py,sha256=IPgnaRih5flDevzJsu6o_ycG3vk2X9Mt4A-MZ7gufNU,18163
-guppylang_internals/checker/expr_checker.py,sha256=cQVigPN-BE-0nfo_8EUSxCgzSFFfRTxA3dvEMZzzGA8,60121
+guppylang_internals/checker/expr_checker.py,sha256=a07sqXQvT1G2CbTuuwb8t7l7n7eCpJSLHiFXXdM-Wpg,60931
 guppylang_internals/checker/func_checker.py,sha256=WxQtwQdYOfvPVHRem__LoBMax5eUzvmqEJXbxmHzG5M,16118
 guppylang_internals/checker/linearity_checker.py,sha256=cVgoUshu6YPEJ2mgk3RUWx38qt52WNMxjyLVV5eqgD4,37160
 guppylang_internals/checker/modifier_checker.py,sha256=ruhEkbT4g9YIJXOGRsfpdzUsbXxEbS95PC1LG-EAl3o,4175
@@ -28,16 +28,16 @@ guppylang_internals/checker/unitary_checker.py,sha256=TVUT4JskaOzNVLcMrQwOd5t5MB
 guppylang_internals/checker/errors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guppylang_internals/checker/errors/comptime_errors.py,sha256=ee42lnVjXbjqirjp6vYaRvbKKexeNV08px1Kqu9eXn8,3436
 guppylang_internals/checker/errors/generic.py,sha256=r-BiSrmJh9jfXlxE029GMQ8yj30_qOTW2RAQsd3HYzs,2050
-guppylang_internals/checker/errors/linearity.py,sha256=VLGvwzfW6uljNjYUEIxNkgt6s3q9-yo1O22BoTiS4Xs,8922
+guppylang_internals/checker/errors/linearity.py,sha256=jKp_IExMySGYjxEw-VbvVNgUewW6jRieseMLB4-twPA,8978
 guppylang_internals/checker/errors/type_errors.py,sha256=KUmcpN3tGLI_8BogcGKfV_N5BO7yqEBPgyHmf8hk-3M,10619
 guppylang_internals/checker/errors/wasm.py,sha256=TlwQRtlA0zpu8xwkBHWPYc25OIb6NrMHRxuYUfyD0Rg,956
 guppylang_internals/compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guppylang_internals/compiler/cfg_compiler.py,sha256=dKAh2dWMUCXHpb5GjRzgT6Npnv74Vx5WqMaaa_X1koI,9004
 guppylang_internals/compiler/core.py,sha256=iWD2K4Ztu1nvK6o5ZIyR_c3UBc4cjBxfgzrZEJuOdfY,31548
-guppylang_internals/compiler/expr_compiler.py,sha256=ZlOP4JnvggjXC3uf0km-nRzk04IbblEdEJLeZpIWFDI,37198
+guppylang_internals/compiler/expr_compiler.py,sha256=piZ4W3TxbQ5jR5BIAf6na2oaOlZSGeprCyere-mpwMM,37932
 guppylang_internals/compiler/func_compiler.py,sha256=0bo28RNsFZDYmllle-yFUXKC0UJsLl2TVjr3gvDMJVA,3377
 guppylang_internals/compiler/hugr_extension.py,sha256=eFUcxzBZoVzXV-AqEOJlh_rJkyuS3vFv1WKGOHjloJs,7966
-guppylang_internals/compiler/modifier_compiler.py,sha256=Ni0ANon4kI8Ro3YIh_jt1-7Ucs12KmWmE7QDq_MDMgw,6464
+guppylang_internals/compiler/modifier_compiler.py,sha256=LrPLldlcFSjhKdHmx8034SLwKLRI-SE8LhEXcOLDNnQ,6506
 guppylang_internals/compiler/qtm_platform_extension.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guppylang_internals/compiler/stmt_compiler.py,sha256=cdOgqzRVP1hYeGbGftgY8LlFRHLWdgFPjlhK-khoMvw,9340
 guppylang_internals/definition/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -46,10 +46,11 @@ guppylang_internals/definition/const.py,sha256=71QVX3xqSaC0u4bsYHPbR_0Csz1Es-P7H
 guppylang_internals/definition/custom.py,sha256=sPYY8o1_WuSNHQazV4KCvUcLer8mvepTYb285XMGkEM,19683
 guppylang_internals/definition/declaration.py,sha256=vwo7P6D3TJU_6wfTWmx6KnmjOCCGLiGjJQ-Zf_02rYM,6038
 guppylang_internals/definition/extern.py,sha256=hEajRYaapKIfX9J7scnusQHc1e_bCxB4oUVWZ-D4c8o,2878
-guppylang_internals/definition/function.py,sha256=LPWvQrlzTnY_18n_myD063p7KdXM51CJIIjmpdBTStY,11395
-guppylang_internals/definition/overloaded.py,sha256=UQ64waMp48gEVDCqEzuJFrRoNJ9saUIRUAynF3T-Gz8,5132
+guppylang_internals/definition/function.py,sha256=974WcrXQi4X9aZMGjP3pWqCkHK_WHbH4Ux1HRAMiheQ,11682
+guppylang_internals/definition/metadata.py,sha256=S3YO0X7YVCxyiTw5KJNNCXdFaprCx8pcX3tPWiWnM2o,3013
+guppylang_internals/definition/overloaded.py,sha256=jwrzaL_P1fYW9TTL-gnPAe0gHLN2kDPbG1-muKT0u1Q,5613
 guppylang_internals/definition/parameter.py,sha256=l60l-yO34gpeuKZ5D3ru8CS8wnQGuoAgqIUP1CrfOF8,2789
-guppylang_internals/definition/pytket_circuits.py,sha256=SkOUg3EwBjpeb3_2PzvkH9xzAvI_OIt-wILY37wv2zI,17010
+guppylang_internals/definition/pytket_circuits.py,sha256=_LCWKc1QzXHdoWommupxMSwdkemjrP5HVUBp4DosrK8,17246
 guppylang_internals/definition/struct.py,sha256=Jed5kcoc57toQr4f7zeB7mr6fSDP1Q2KRnmGJvbVXF4,15572
 guppylang_internals/definition/traced.py,sha256=hMHnrLKdbMvmmzmcJRvOCR-WiPHJ3x5ji0am436HNTQ,5592
 guppylang_internals/definition/ty.py,sha256=5Jt7twY8v1cE7noZ_RYfo0X55KYV6JI0itdHW9vvZs0,2085
@@ -63,8 +64,8 @@ guppylang_internals/std/_internal/debug.py,sha256=j6bGg9TFn4fR8-H8Hk10BfY9Ekanfi
 guppylang_internals/std/_internal/util.py,sha256=e_sawDuuk1YFpbEQXbpAvWMNeTlkGb4P0t6Ed0JpP9M,8305
 guppylang_internals/std/_internal/compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guppylang_internals/std/_internal/compiler/arithmetic.py,sha256=_Nf-P3GwTp-ZVLz62Hz9ModD74R41hKqutNGmp5Mn6g,4287
-guppylang_internals/std/_internal/compiler/array.py,sha256=YTFzInN7DkU4M_AASHR__D_9bouvaNrYNRKxsO3-Fek,13491
-guppylang_internals/std/_internal/compiler/either.py,sha256=LzLSfsafwVAgaeX8d91IRmrxK6kx0YC_MtGSBEgBsbs,4716
+guppylang_internals/std/_internal/compiler/array.py,sha256=l3FqmqRr-95a0lkTW1-MCd2VzFDBYHZR2-Aw38gW0bY,14803
+guppylang_internals/std/_internal/compiler/either.py,sha256=LEVPfkINfYr5qENkszzgYYI5zrjaYPHlPnk0nNBrBaA,5425
 guppylang_internals/std/_internal/compiler/frozenarray.py,sha256=BZMSSYTieqcFaAXGTR0nw2b7eN5LK2Et4vNZSBFRcyI,2361
 guppylang_internals/std/_internal/compiler/futures.py,sha256=nIaxXCGj4BPI_to_Q87gQEqN94Q8hb09ICkODZVOJrQ,1095
 guppylang_internals/std/_internal/compiler/list.py,sha256=Tqvs-J7iL5TxG5qgk-dboXU3-y7uZq-tQ9r9xFhmw4c,12574
@@ -74,14 +75,14 @@ guppylang_internals/std/_internal/compiler/platform.py,sha256=3TMYdRO--Sabapo4K0
 guppylang_internals/std/_internal/compiler/prelude.py,sha256=2pOmi1JNBHsETkC4EGskbFBAZAlAJ4IvWZLe5v4DIFM,9635
 guppylang_internals/std/_internal/compiler/qsystem.py,sha256=dKSpvpxF7WRfWuDj0u7zShEhTL6mkAr9pQNyYVoa8vM,1940
 guppylang_internals/std/_internal/compiler/quantum.py,sha256=gXuB1vpRl8ipgwwEYPCgoMPiqPUJ908Msl09jJFdWxg,3930
-guppylang_internals/std/_internal/compiler/tket_bool.py,sha256=ceO9BBF3HhjNAkc4dObJBH13Kpn08-pSaksjl3yoOa4,1207
-guppylang_internals/std/_internal/compiler/tket_exts.py,sha256=E7Ywu6xiMepkFoNYZ90rBMPLi3l1MlZSTJE0YmO6TAo,1540
+guppylang_internals/std/_internal/compiler/tket_bool.py,sha256=yvZRArJIVnCysdfvg6TSz61wwt9ikZh5N5EX4DF2UfE,1114
+guppylang_internals/std/_internal/compiler/tket_exts.py,sha256=UP43DbvDoXetM0qIYGEbTx4h0lINf3n5GZ67VphMUp8,1514
 guppylang_internals/std/_internal/compiler/wasm.py,sha256=1G8EzrnN3Yv12hIdv2XOg4Hq-QlvRYl7-4QbZYLYyM4,5727
 guppylang_internals/tracing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 guppylang_internals/tracing/builtins_mock.py,sha256=iKgrs626DVhdN7nJroKBLstWGwkr7PzJI4CrgqkMyTA,2963
 guppylang_internals/tracing/frozenlist.py,sha256=sINk-PZTw4dNThF5GK9AZxAeX5ap-g_hbqxZ79GtLAc,1823
 guppylang_internals/tracing/function.py,sha256=K2rEey0awOxwfljGk4uezRmXode7rgOKQY1VN94wOIo,7901
-guppylang_internals/tracing/object.py,sha256=UMysud9Cc4pHqIDF2qn0zwo97q5d1IqMn1CHxvcitBs,20393
+guppylang_internals/tracing/object.py,sha256=WWlYUMcNjS9XKGR6NEJKd7v9rtrensAHizySppiJPfo,20558
 guppylang_internals/tracing/state.py,sha256=J-fG0dZh9IeB6hpLfyp5IwqS2TW0Zr8XloMmuIHWS6Q,2083
 guppylang_internals/tracing/unpacking.py,sha256=6Df9h4pFS6mebyU3VR5DfO87Rs_QbTdSkLMNjpaM0Xc,8728
 guppylang_internals/tracing/util.py,sha256=zzVUeY7Ax4v_ZQh7QmckYaOWsg7BRZg6-oX4VWmytDU,3054
@@ -98,7 +99,7 @@ guppylang_internals/tys/qubit.py,sha256=Y7RRc3_bP9LIoAMqjDsVNVzaplgF7h26L2OJB5Xp
 guppylang_internals/tys/subst.py,sha256=fMIh7jNMMNiKjlr3WMxAwY_ovX1qTaz_c5foruYkLPs,3049
 guppylang_internals/tys/ty.py,sha256=kRkI_QfPbITKuHre29Ejha55Y68j-aiLAWSBdvO1Ma8,31115
 guppylang_internals/tys/var.py,sha256=zACXv2IvGrqjDryC6lMyZpNnDb3SBRM2SlTOyq6WJdo,1173
-guppylang_internals-0.26.0.dist-info/METADATA,sha256=yTv-p1nskM4Z4zIz0laFimpTCmF5bYPq6NxG_t_h8PY,14853
-guppylang_internals-0.26.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-guppylang_internals-0.26.0.dist-info/licenses/LICENCE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-guppylang_internals-0.26.0.dist-info/RECORD,,
+guppylang_internals-0.27.0.dist-info/METADATA,sha256=6xRat3Ig_bf94-LOSR_KqMeXJgUqpIyiGqMzobzhAdE,14853
+guppylang_internals-0.27.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+guppylang_internals-0.27.0.dist-info/licenses/LICENCE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+guppylang_internals-0.27.0.dist-info/RECORD,,