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

guppylang_internals/std/_internal/checker.py

@@ -4,9 +4,9 @@ from typing import ClassVar
 
 from typing_extensions import assert_never
 
-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.ast_util import get_type, with_loc, with_type
+from guppylang_internals.checker.core import Context
+from guppylang_internals.checker.errors.generic import UnsupportedError
 from guppylang_internals.checker.errors.type_errors import (
     ArrayComprUnknownSizeError,
     TypeMismatchError,
@@ -33,8 +33,6 @@ from guppylang_internals.nodes import (
     GlobalCall,
     MakeIter,
     PanicExpr,
-    PlaceNode,
-    ResultExpr,
 )
 from guppylang_internals.tys.arg import ConstArg, TypeArg
 from guppylang_internals.tys.builtin import (
@@ -45,7 +43,6 @@ from guppylang_internals.tys.builtin import (
     get_iter_size,
     int_type,
     is_array_type,
-    is_bool_type,
     is_sized_iter_type,
     nat_type,
     sized_iter_type,
@@ -58,7 +55,6 @@ from guppylang_internals.tys.ty import (
     FunctionType,
     InputFlags,
     NoneType,
-    NumericType,
     Type,
     unify,
 )
@@ -302,80 +298,6 @@ class NewArrayChecker(CustomCallChecker):
         return with_loc(compr, array_compr), array_type(elt_ty, size)
 
 
-#: Maximum length of a tag in the `result` function.
-TAG_MAX_LEN = 200
-
-
-@dataclass(frozen=True)
-class TooLongError(Error):
-    title: ClassVar[str] = "Tag too long"
-    span_label: ClassVar[str] = "Result tag is too long"
-
-    @dataclass(frozen=True)
-    class Hint(Note):
-        message: ClassVar[str] = f"Result tags are limited to {TAG_MAX_LEN} bytes"
-
-
-class ResultChecker(CustomCallChecker):
-    """Call checker for the `result` function."""
-
-    @dataclass(frozen=True)
-    class InvalidError(Error):
-        title: ClassVar[str] = "Invalid Result"
-        span_label: ClassVar[str] = "Expression of type `{ty}` is not a valid result."
-        ty: Type
-
-        @dataclass(frozen=True)
-        class Explanation(Note):
-            message: ClassVar[str] = (
-                "Only numeric values or arrays thereof are allowed as results"
-            )
-
-    def synthesize(self, args: list[ast.expr]) -> tuple[ast.expr, Type]:
-        check_num_args(2, len(args), self.node)
-        [tag, value] = args
-        tag, _ = ExprChecker(self.ctx).check(tag, string_type())
-        match tag:
-            case ast.Constant(value=str(v)):
-                tag_value = v
-            case PlaceNode(place=ComptimeVariable(static_value=str(v))):
-                tag_value = v
-            case _:
-                raise GuppyTypeError(ExpectedError(tag, "a string literal"))
-        if len(tag_value.encode("utf-8")) > TAG_MAX_LEN:
-            err: Error = TooLongError(tag)
-            err.add_sub_diagnostic(TooLongError.Hint(None))
-            raise GuppyTypeError(err)
-        value, ty = ExprSynthesizer(self.ctx).synthesize(value)
-        # We only allow numeric values or vectors of numeric values
-        err = ResultChecker.InvalidError(value, ty)
-        err.add_sub_diagnostic(ResultChecker.InvalidError.Explanation(None))
-        if self._is_numeric_or_bool_type(ty):
-            base_ty = ty
-            array_len: Const | None = None
-        elif is_array_type(ty):
-            [ty_arg, len_arg] = ty.args
-            assert isinstance(ty_arg, TypeArg)
-            assert isinstance(len_arg, ConstArg)
-            if not self._is_numeric_or_bool_type(ty_arg.ty):
-                raise GuppyError(err)
-            base_ty = ty_arg.ty
-            array_len = len_arg.const
-        else:
-            raise GuppyError(err)
-        node = ResultExpr(value, base_ty, array_len, tag_value)
-        return with_loc(self.node, node), NoneType()
-
-    def check(self, args: list[ast.expr], ty: Type) -> tuple[ast.expr, Subst]:
-        expr, res_ty = self.synthesize(args)
-        expr, subst, _ = check_type_against(res_ty, ty, expr, self.ctx)
-        return expr, subst
-
-    @staticmethod
-    def _is_numeric_or_bool_type(ty: Type) -> bool:
-        return isinstance(ty, NumericType) or is_bool_type(ty)
-
-
 class PanicChecker(CustomCallChecker):
     """Call checker for the `panic`  function."""
 
@@ -395,18 +317,16 @@ class PanicChecker(CustomCallChecker):
                 err.add_sub_diagnostic(PanicChecker.NoMessageError.Suggestion(None))
                 raise GuppyTypeError(err)
             case [msg, *rest]:
+                # Check type of message and synthesize types for additional values.
                 msg, _ = ExprChecker(self.ctx).check(msg, string_type())
-                match msg:
-                    case ast.Constant(value=str(v)):
-                        msg_value = v
-                    case PlaceNode(place=ComptimeVariable(static_value=str(v))):
-                        msg_value = v
-                    case _:
-                        raise GuppyTypeError(ExpectedError(msg, "a string literal"))
                 vals = [ExprSynthesizer(self.ctx).synthesize(val)[0] for val in rest]
                 # TODO variable signals once default arguments are available
+                # TODO this will also allow us to remove this manual AST node hack
+                signal_expr = with_type(
+                    int_type(), with_loc(self.node, ast.Constant(value=1))
+                )
                 node = PanicExpr(
-                    kind=ExitKind.Panic, msg=msg_value, values=vals, signal=1
+                    kind=ExitKind.Panic, msg=msg, values=vals, signal=signal_expr
                 )
                 return with_loc(self.node, node), NoneType()
             case args:
@@ -454,31 +374,16 @@ class ExitChecker(CustomCallChecker):
                 )
                 raise GuppyTypeError(signal_err)
             case [msg, signal, *rest]:
+                # Check types for message and signal and synthesize types for additional
+                # values.
                 msg, _ = ExprChecker(self.ctx).check(msg, string_type())
-                match msg:
-                    case ast.Constant(value=str(v)):
-                        msg_value = v
-                    case PlaceNode(place=ComptimeVariable(static_value=str(v))):
-                        msg_value = v
-                    case _:
-                        raise GuppyTypeError(ExpectedError(msg, "a string literal"))
-                # TODO allow variable signals after https://github.com/CQCL/hugr/issues/1863
                 signal, _ = ExprChecker(self.ctx).check(signal, int_type())
-                match signal:
-                    case ast.Constant(value=int(s)):
-                        signal_value = s
-                    case PlaceNode(place=ComptimeVariable(static_value=int(s))):
-                        signal_value = s
-                    case _:
-                        raise GuppyTypeError(
-                            ExpectedError(signal, "an integer literal")
-                        )
                 vals = [ExprSynthesizer(self.ctx).synthesize(val)[0] for val in rest]
                 node = PanicExpr(
                     kind=ExitKind.ExitShot,
-                    msg=msg_value,
+                    msg=msg,
                     values=vals,
-                    signal=signal_value,
+                    signal=signal,
                 )
                 return with_loc(self.node, node), NoneType()
             case args:

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."""
@@ -261,7 +270,7 @@ class NewArrayCompiler(ArrayCompiler):
 
     def build_classical_array(self, elems: list[Wire]) -> Wire:
         """Lowers a call to `array.__new__` for classical arrays."""
-        # See https://github.com/CQCL/guppylang/issues/629
+        # See https://github.com/quantinuum/guppylang/issues/629
         return self.build_linear_array(elems)
 
     def build_linear_array(self, elems: list[Wire]) -> Wire:
@@ -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/list.py

@@ -328,7 +328,7 @@ def _list_new_classical(
     builder: DfBase[ops.DfParentOp], elem_type: ht.Type, args: list[Wire]
 ) -> Wire:
     # This may be simplified in the future with a `new` or `with_capacity` list op
-    # See https://github.com/CQCL/hugr/issues/1508
+    # See https://github.com/quantinuum/hugr/issues/1508
     lst = builder.load(ListVal([], elem_ty=elem_type))
     push_op = list_push(elem_type)
     for elem in args:

guppylang_internals/std/_internal/compiler/platform.py

@@ -0,0 +1,153 @@
+from dataclasses import dataclass
+from typing import ClassVar
+
+import hugr
+from hugr import Wire, ops, tys
+
+from guppylang_internals.ast_util import AstNode
+from guppylang_internals.compiler.core import CompilerContext
+from guppylang_internals.compiler.expr_compiler import array_read_bool
+from guppylang_internals.definition.custom import (
+    CustomCallCompiler,
+    CustomInoutCallCompiler,
+)
+from guppylang_internals.definition.value import CallReturnWires
+from guppylang_internals.diagnostic import Error, Note
+from guppylang_internals.error import GuppyError, InternalGuppyError
+from guppylang_internals.std._internal.compiler.array import (
+    array_clone,
+    array_map,
+    array_to_std_array,
+)
+from guppylang_internals.std._internal.compiler.tket_bool import OpaqueBool, read_bool
+from guppylang_internals.std._internal.compiler.tket_exts import RESULT_EXTENSION
+from guppylang_internals.tys.arg import Argument, ConstArg
+from guppylang_internals.tys.builtin import get_element_type, is_bool_type
+from guppylang_internals.tys.const import BoundConstVar, ConstValue
+from guppylang_internals.tys.ty import NumericType
+
+#: Maximum length of a tag in the `result` function.
+TAG_MAX_LEN = 200
+
+
+@dataclass(frozen=True)
+class TooLongError(Error):
+    title: ClassVar[str] = "Tag too long"
+    span_label: ClassVar[str] = "Result tag is too long"
+
+    @dataclass(frozen=True)
+    class Hint(Note):
+        message: ClassVar[str] = f"Result tags are limited to {TAG_MAX_LEN} bytes"
+
+    @dataclass(frozen=True)
+    class GenericHint(Note):
+        message: ClassVar[str] = "Parameter `{param}` was instantiated to `{value}`"
+        param: str
+        value: str
+
+
+class ResultCompiler(CustomCallCompiler):
+    """Custom compiler for overloads of the `result` function.
+
+    See `ArrayResultCompiler` for the compiler that handles results involving arrays.
+    """
+
+    def __init__(self, op_name: str, with_int_width: bool = False):
+        self.op_name = op_name
+        self.with_int_width = with_int_width
+
+    def compile(self, args: list[Wire]) -> list[Wire]:
+        assert self.func is not None
+        [value] = args
+        ty = self.func.ty.inputs[1].ty
+        hugr_ty = ty.to_hugr(self.ctx)
+        args = [tag_to_hugr(self.type_args[0], self.ctx, self.node)]
+        if self.with_int_width:
+            args.append(tys.BoundedNatArg(NumericType.INT_WIDTH))
+        # Bool results need an extra conversion into regular hugr bools
+        if is_bool_type(ty):
+            value = self.builder.add_op(read_bool(), value)
+            hugr_ty = tys.Bool
+        op = RESULT_EXTENSION.get_op(self.op_name)
+        sig = tys.FunctionType(input=[hugr_ty], output=[])
+        self.builder.add_op(op.instantiate(args, sig), value)
+        return []
+
+
+class ArrayResultCompiler(CustomInoutCallCompiler):
+    """Custom compiler for overloads of the `result` function accepting arrays.
+
+    See `ResultCompiler` for the compiler that handles basic results.
+    """
+
+    def __init__(self, op_name: str, with_int_width: bool = False):
+        self.op_name = op_name
+        self.with_int_width = with_int_width
+
+    def compile_with_inouts(self, args: list[Wire]) -> CallReturnWires:
+        assert self.func is not None
+        array_ty = self.func.ty.inputs[1].ty
+        elem_ty = get_element_type(array_ty)
+        [tag_arg, size_arg] = self.type_args
+        [arr] = args
+
+        # As `borrow_array`s used by Guppy are linear, we need to clone it (knowing
+        # that all elements in it are copyable) to avoid linearity violations when
+        # both passing it to the result operation and returning it (as an inout
+        # argument).
+        hugr_elem_ty = elem_ty.to_hugr(self.ctx)
+        hugr_size = size_arg.to_hugr(self.ctx)
+        arr, out_arr = self.builder.add_op(array_clone(hugr_elem_ty, hugr_size), arr)
+        # For bool arrays, we furthermore need to coerce a read on all the array
+        # elements
+        if is_bool_type(elem_ty):
+            array_read = array_read_bool(self.ctx)
+            array_read = self.builder.load_function(array_read)
+            map_op = array_map(OpaqueBool, hugr_size, tys.Bool)
+            arr = self.builder.add_op(map_op, arr, array_read).out(0)
+            hugr_elem_ty = tys.Bool
+        # Turn `borrow_array` into regular `array`
+        arr = self.builder.add_op(array_to_std_array(hugr_elem_ty, hugr_size), arr).out(
+            0
+        )
+
+        hugr_ty = hugr.std.collections.array.Array(hugr_elem_ty, hugr_size)
+        sig = tys.FunctionType(input=[hugr_ty], output=[])
+        args = [tag_to_hugr(tag_arg, self.ctx, self.node), hugr_size]
+        if self.with_int_width:
+            args.append(tys.BoundedNatArg(NumericType.INT_WIDTH))
+        op = ops.ExtOp(RESULT_EXTENSION.get_op(self.op_name), signature=sig, args=args)
+        self.builder.add_op(op, arr)
+        return CallReturnWires([], [out_arr])
+
+
+def tag_to_hugr(tag_arg: Argument, ctx: CompilerContext, loc: AstNode) -> tys.TypeArg:
+    """Helper function to convert the Guppy tag comptime argument into a Hugr type arg.
+
+    Takes care of reading the tag value from the current monomorphization and checks
+    that the tag fits into `TAG_MAX_LEN`.
+    """
+    is_generic: BoundConstVar | None = None
+    match tag_arg:
+        case ConstArg(const=ConstValue(value=str(value))):
+            tag = value
+        case ConstArg(const=BoundConstVar(idx=idx) as var):
+            is_generic = var
+            assert ctx.current_mono_args is not None
+            match ctx.current_mono_args[idx]:
+                case ConstArg(const=ConstValue(value=str(value))):
+                    tag = value
+                case _:
+                    raise InternalGuppyError("Invalid tag monomorphization")
+        case _:
+            raise InternalGuppyError("Invalid tag argument")
+
+    if len(tag.encode("utf-8")) > TAG_MAX_LEN:
+        err = TooLongError(loc)
+        err.add_sub_diagnostic(TooLongError.Hint(None))
+        if is_generic:
+            err.add_sub_diagnostic(
+                TooLongError.GenericHint(None, is_generic.display_name, tag)
+            )
+        raise GuppyError(err)
+    return tys.StringArg(tag)

guppylang_internals/std/_internal/compiler/prelude.py

@@ -73,6 +73,14 @@ def panic(
     return ops.ExtOp(op_def, sig, args)
 
 
+def make_error() -> ops.ExtOp:
+    """Returns an operation that makes an error."""
+    op_def = hugr.std.PRELUDE.get_op("MakeError")
+    args: list[ht.TypeArg] = []
+    sig = ht.FunctionType([ht.USize(), hugr.std.prelude.STRING_T], [error_type()])
+    return ops.ExtOp(op_def, sig, args)
+
+
 # ------------------------------------------------------
 # --------- Custom compilers for non-native ops --------
 # ------------------------------------------------------
@@ -90,14 +98,14 @@ def build_panic(
     return builder.add_op(op, err, *args)
 
 
-def build_error(builder: DfBase[P], signal: int, msg: str) -> Wire:
+def build_static_error(builder: DfBase[P], signal: int, msg: str) -> Wire:
     """Constructs and loads a static error value."""
     val = ErrorVal(signal, msg)
     return builder.load(builder.add_const(val))
 
 
 # TODO: Common up build_unwrap_right and build_unwrap_left below once
-#  https://github.com/CQCL/hugr/issues/1596 is fixed
+#  https://github.com/quantinuum/hugr/issues/1596 is fixed
 
 
 def build_unwrap_right(
@@ -111,7 +119,7 @@ def build_unwrap_right(
     assert isinstance(result_ty, ht.Sum)
     [left_tys, right_tys] = result_ty.variant_rows
     with conditional.add_case(0) as case:
-        error = build_error(case, error_signal, error_msg)
+        error = build_static_error(case, error_signal, error_msg)
         case.set_outputs(*build_panic(case, left_tys, right_tys, error, *case.inputs()))
     with conditional.add_case(1) as case:
         case.set_outputs(*case.inputs())
@@ -134,7 +142,7 @@ def build_unwrap_left(
     with conditional.add_case(0) as case:
         case.set_outputs(*case.inputs())
     with conditional.add_case(1) as case:
-        error = build_error(case, error_signal, error_msg)
+        error = build_static_error(case, error_signal, error_msg)
         case.set_outputs(*build_panic(case, right_tys, left_tys, error, *case.inputs()))
     return conditional.to_node()
 

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

@@ -20,6 +20,7 @@ from tket_exts import (
 BOOL_EXTENSION = tket_exts.bool()
 DEBUG_EXTENSION = debug()
 FUTURES_EXTENSION = futures()
+GLOBAL_PHASE_EXTENSION = global_phase()
 GUPPY_EXTENSION = guppy()
 MODIFIER_EXTENSION = modifier()
 QSYSTEM_EXTENSION = qsystem()
@@ -29,14 +30,14 @@ QUANTUM_EXTENSION = quantum()
 RESULT_EXTENSION = result()
 ROTATION_EXTENSION = rotation()
 WASM_EXTENSION = wasm()
-MODIFIER_EXTENSION = modifier()
-GLOBAL_PHASE_EXTENSION = global_phase()
 
 TKET_EXTENSIONS = [
     BOOL_EXTENSION,
     DEBUG_EXTENSION,
     FUTURES_EXTENSION,
+    GLOBAL_PHASE_EXTENSION,
     GUPPY_EXTENSION,
+    MODIFIER_EXTENSION,
     QSYSTEM_EXTENSION,
     QSYSTEM_RANDOM_EXTENSION,
     QSYSTEM_UTILS_EXTENSION,
@@ -44,8 +45,6 @@ TKET_EXTENSIONS = [
     RESULT_EXTENSION,
     ROTATION_EXTENSION,
     WASM_EXTENSION,
-    MODIFIER_EXTENSION,
-    GLOBAL_PHASE_EXTENSION,
 ]
 
 
@@ -60,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/std/_internal/debug.py

@@ -3,6 +3,7 @@ from dataclasses import dataclass
 from typing import ClassVar, cast
 
 from guppylang_internals.ast_util import with_loc
+from guppylang_internals.checker.core import ComptimeVariable
 from guppylang_internals.checker.errors.generic import ExpectedError
 from guppylang_internals.checker.errors.type_errors import WrongNumberOfArgsError
 from guppylang_internals.checker.expr_checker import (
@@ -14,14 +15,14 @@ from guppylang_internals.definition.custom import CustomCallChecker
 from guppylang_internals.definition.ty import TypeDef
 from guppylang_internals.diagnostic import Error
 from guppylang_internals.error import GuppyTypeError
-from guppylang_internals.nodes import StateResultExpr
-from guppylang_internals.std._internal.checker import TAG_MAX_LEN, TooLongError
+from guppylang_internals.nodes import GenericParamValue, PlaceNode, StateResultExpr
 from guppylang_internals.tys.builtin import (
     get_array_length,
     get_element_type,
     is_array_type,
     string_type,
 )
+from guppylang_internals.tys.const import Const, ConstValue
 from guppylang_internals.tys.ty import (
     FuncInput,
     FunctionType,
@@ -43,12 +44,16 @@ class StateResultChecker(CustomCallChecker):
 
     def synthesize(self, args: list[ast.expr]) -> tuple[ast.expr, Type]:
         tag, _ = ExprChecker(self.ctx).check(args[0], string_type())
-        if not isinstance(tag, ast.Constant) or not isinstance(tag.value, str):
-            raise GuppyTypeError(ExpectedError(tag, "a string literal"))
-        if len(tag.value.encode("utf-8")) > TAG_MAX_LEN:
-            err: Error = TooLongError(tag)
-            err.add_sub_diagnostic(TooLongError.Hint(None))
-            raise GuppyTypeError(err)
+        tag_value: Const
+        match tag:
+            case ast.Constant(value=str(v)):
+                tag_value = ConstValue(string_type(), v)
+            case PlaceNode(place=ComptimeVariable(static_value=str(v))):
+                tag_value = ConstValue(string_type(), v)
+            case GenericParamValue() as param_value:
+                tag_value = param_value.param.to_bound().const
+            case _:
+                raise GuppyTypeError(ExpectedError(tag, "a string literal"))
         syn_args: list[ast.expr] = [tag]
 
         if len(args) < 2:
@@ -90,6 +95,10 @@ class StateResultChecker(CustomCallChecker):
         args, ret_ty, inst = synthesize_call(func_ty, syn_args, self.node, self.ctx)
         assert len(inst) == 0, "func_ty is not generic"
         node = StateResultExpr(
-            tag=tag.value, args=args, func_ty=func_ty, array_len=array_len
+            tag_value=tag_value,
+            tag_expr=tag,
+            args=args,
+            func_ty=func_ty,
+            array_len=array_len,
         )
         return with_loc(self.node, node), ret_ty

guppylang_internals/std/_internal/util.py

@@ -129,7 +129,7 @@ def int_op(
     # Ideally we'd be able to derive the arguments from the input/output types,
     # but the amount of variables does not correlate with the signature for the
     # integer ops in hugr :/
-    # https://github.com/CQCL/hugr/blob/bfa13e59468feb0fc746677ea3b3a4341b2ed42e/hugr-core/src/std_extensions/arithmetic/int_ops.rs#L116
+    # https://github.com/quantinuum/hugr/blob/bfa13e59468feb0fc746677ea3b3a4341b2ed42e/hugr-core/src/std_extensions/arithmetic/int_ops.rs#L116
     #
     # For now, we just instantiate every type argument to a 64-bit integer.
     args: list[ht.TypeArg] = [int_arg() for _ in range(n_vars)]

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
@@ -539,6 +543,16 @@ class TracingDefMixin(DunderMixin):
 
     def to_guppy_object(self) -> GuppyObject:
         state = get_tracing_state()
+        defn = ENGINE.get_checked(self.id)
+        # TODO: For generic functions, we need to know an instantiation for their type
+        #  parameters. Maybe we should pass them to `to_guppy_object`? Either way, this
+        #  will require some more plumbing of type inference information through the
+        #  comptime logic. For now, let's just bail on generic functions.
+        #  See https://github.com/quantinuum/guppylang/issues/1336
+        if isinstance(defn, CallableDef) and defn.ty.parametrized:
+            raise GuppyComptimeError(
+                f"Cannot infer type parameters of generic function `{defn.name}`"
+            )
         defn, [] = state.ctx.build_compiled_def(self.id, type_args=[])
         if isinstance(defn, CompiledValueDef):
             wire = defn.load(state.dfg, state.ctx, state.node)