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

guppylang_internals/nodes.py

@@ -9,7 +9,13 @@ from guppylang_internals.ast_util import AstNode
 from guppylang_internals.span import Span, to_span
 from guppylang_internals.tys.const import Const
 from guppylang_internals.tys.subst import Inst
-from guppylang_internals.tys.ty import FunctionType, StructType, TupleType, Type
+from guppylang_internals.tys.ty import (
+    FunctionType,
+    StructType,
+    TupleType,
+    Type,
+    UnitaryFlags,
+)
 
 if TYPE_CHECKING:
     from guppylang_internals.cfg.cfg import CFG
@@ -250,22 +256,6 @@ class ComptimeExpr(ast.expr):
     _fields = ("value",)
 
 
-class ResultExpr(ast.expr):
-    """A `result(tag, value)` expression."""
-
-    value: ast.expr
-    base_ty: Type
-    #: Array length in case this is an array result, otherwise `None`
-    array_len: Const | None
-    tag: str
-
-    _fields = ("value", "base_ty", "array_len", "tag")
-
-    @property
-    def args(self) -> list[ast.expr]:
-        return [self.value]
-
-
 class ExitKind(Enum):
     ExitShot = 0  # Exit the current shot
     Panic = 1  # Panic the program ending all shots
@@ -275,8 +265,8 @@ class PanicExpr(ast.expr):
     """A `panic(msg, *args)` or `exit(msg, *args)` expression ."""
 
     kind: ExitKind
-    signal: int
-    msg: str
+    signal: ast.expr
+    msg: ast.expr
     values: list[ast.expr]
 
     _fields = ("kind", "signal", "msg", "values")
@@ -293,17 +283,16 @@ class BarrierExpr(ast.expr):
 class StateResultExpr(ast.expr):
     """A `state_result(tag, *args)` expression."""
 
-    tag: str
+    tag_value: Const
+    tag_expr: ast.expr
     args: list[ast.expr]
     func_ty: FunctionType
     #: Array length in case this is an array result, otherwise `None`
     array_len: Const | None
-    _fields = ("tag", "args", "func_ty", "has_array_input")
+    _fields = ("tag_value", "tag_expr", "args", "func_ty", "has_array_input")
 
 
-AnyCall = (
-    LocalCall | GlobalCall | TensorCall | BarrierExpr | ResultExpr | StateResultExpr
-)
+AnyCall = LocalCall | GlobalCall | TensorCall | BarrierExpr | StateResultExpr
 
 
 class InoutReturnSentinel(ast.expr):
@@ -500,6 +489,16 @@ class ModifiedBlock(ast.With):
         else:
             raise TypeError(f"Unknown modifier: {modifier}")
 
+    def flags(self) -> UnitaryFlags:
+        flags = UnitaryFlags.NoFlags
+        if self.is_dagger():
+            flags |= UnitaryFlags.Dagger
+        if self.is_control():
+            flags |= UnitaryFlags.Control
+        if self.is_power():
+            flags |= UnitaryFlags.Power
+        return flags
+
 
 class CheckedModifiedBlock(ast.With):
     def_id: "DefId"

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

@@ -261,7 +261,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:

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_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,
 ]
 
 

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

@@ -539,6 +539,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)

guppylang_internals/tys/errors.py

@@ -5,7 +5,7 @@ from guppylang_internals.diagnostic import Error, Help, Note
 
 if TYPE_CHECKING:
     from guppylang_internals.definition.parameter import ParamDef
-    from guppylang_internals.tys.ty import Type
+    from guppylang_internals.tys.ty import Type, UnitaryFlags
 
 
 @dataclass(frozen=True)
@@ -182,3 +182,25 @@ class InvalidFlagError(Error):
 class FlagNotAllowedError(Error):
     title: ClassVar[str] = "Invalid annotation"
     span_label: ClassVar[str] = "`@` type annotations are not allowed in this position"
+
+
+@dataclass(frozen=True)
+class UnitaryCallError(Error):
+    title: ClassVar[str] = "Unitary constraint violation"
+    span_label: ClassVar[str] = (
+        "This function cannot be called in a {render_flags} context"
+    )
+    flags: "UnitaryFlags"
+
+    @property
+    def render_flags(self) -> str:
+        from guppylang_internals.tys.ty import UnitaryFlags
+
+        if self.flags == UnitaryFlags.Dagger:
+            return "dagger"
+        elif self.flags == UnitaryFlags.Control:
+            return "control"
+        elif self.flags == UnitaryFlags.Power:
+            return "power"
+        else:
+            return "unitary"

guppylang_internals/tys/parsing.py

@@ -107,7 +107,7 @@ def arg_from_ast(node: AstNode, ctx: TypeParsingCtx) -> Argument:
                 return ConstArg(ConstValue(bool_type(), v))
             # Integer literals are turned into nat args.
             # TODO: To support int args, we need proper inference logic here
-            #   See https://github.com/CQCL/guppylang/issues/1030
+            #   See https://github.com/quantinuum/guppylang/issues/1030
             case int(v) if v >= 0:
                 nat_ty = NumericType(NumericType.Kind.Nat)
                 return ConstArg(ConstValue(nat_ty, v))
@@ -117,7 +117,7 @@ def arg_from_ast(node: AstNode, ctx: TypeParsingCtx) -> Argument:
             # String literals are ignored for now since they could also be stringified
             # types.
             # TODO: To support string args, we need proper inference logic here
-            #   See https://github.com/CQCL/guppylang/issues/1030
+            #   See https://github.com/quantinuum/guppylang/issues/1030
             case str(_):
                 pass
 
@@ -289,7 +289,7 @@ def check_function_arg(
         ctx.param_var_mapping[name] = ConstParam(
             len(ctx.param_var_mapping), name, ty, from_comptime_arg=True
         )
-    return FuncInput(ty, flags)
+    return FuncInput(ty, flags, name)
 
 
 if sys.version_info >= (3, 12):