guppylang-internals 0.25.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.25.0"
+__version__ = "0.27.0"

guppylang_internals/cfg/builder.py

@@ -46,7 +46,7 @@ from guppylang_internals.nodes import (
     Power,
 )
 from guppylang_internals.span import Span, to_span
-from guppylang_internals.tys.ty import NoneType
+from guppylang_internals.tys.ty import NoneType, UnitaryFlags
 
 # In order to build expressions, need an endless stream of unique temporary variables
 # to store intermediate results
@@ -78,7 +78,13 @@ class CFGBuilder(AstVisitor[BB | None]):
     cfg: CFG
     globals: Globals
 
-    def build(self, nodes: list[ast.stmt], returns_none: bool, globals: Globals) -> CFG:
+    def build(
+        self,
+        nodes: list[ast.stmt],
+        returns_none: bool,
+        globals: Globals,
+        unitary_flags: UnitaryFlags = UnitaryFlags.NoFlags,
+    ) -> CFG:
         """Builds a CFG from a list of ast nodes.
 
         We also require the expected number of return ports for the whole CFG. This is
@@ -86,6 +92,7 @@ class CFGBuilder(AstVisitor[BB | None]):
         variables.
         """
         self.cfg = CFG()
+        self.cfg.unitary_flags = unitary_flags
         self.globals = globals
 
         final_bb = self.visit_stmts(
@@ -273,6 +280,7 @@ class CFGBuilder(AstVisitor[BB | None]):
 
         func_ty = check_signature(node, self.globals)
         returns_none = isinstance(func_ty.output, NoneType)
+        # No UnitaryFlags are assigned to nested functions
         cfg = CFGBuilder().build(node.body, returns_none, self.globals)
 
         new_node = NestedFunctionDef(
@@ -300,6 +308,13 @@ class CFGBuilder(AstVisitor[BB | None]):
             modifier = self._handle_withitem(item)
             new_node.push_modifier(modifier)
 
+        # FIXME: Currently, the unitary flags is not set correctly if there are nested
+        # `with` blocks. This is because the outer block's unitary flags are not
+        # propagated to the outer block. The following line should calculate the sum
+        # of the unitary flags of the outer block and modifiers applied in this
+        # `with` block.
+        cfg.unitary_flags = new_node.flags()
+
         set_location_from(new_node, node)
         bb.statements.append(new_node)
         return bb
@@ -653,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/cfg/cfg.py

@@ -12,6 +12,7 @@ from guppylang_internals.cfg.analysis import (
 )
 from guppylang_internals.cfg.bb import BB, BBStatement, VariableStats
 from guppylang_internals.nodes import InoutReturnSentinel
+from guppylang_internals.tys.ty import UnitaryFlags
 
 T = TypeVar("T", bound=BB)
 
@@ -29,6 +30,7 @@ class BaseCFG(Generic[T]):
 
     #: Set of variables defined in this CFG
     assigned_somewhere: set[str]
+    unitary_flags: UnitaryFlags
 
     def __init__(
         self, bbs: list[T], entry_bb: T | None = None, exit_bb: T | None = None
@@ -42,6 +44,7 @@ class BaseCFG(Generic[T]):
         self.ass_before = {}
         self.maybe_ass_before = {}
         self.assigned_somewhere = set()
+        self.unitary_flags = UnitaryFlags.NoFlags
 
     def ancestors(self, *bbs: T) -> Iterator[T]:
         """Returns an iterator over all ancestors of the given BBs in BFS order."""

guppylang_internals/checker/cfg_checker.py

@@ -149,11 +149,17 @@ def check_cfg(
     checked_cfg.maybe_ass_before = {
         compiled[bb]: cfg.maybe_ass_before[bb] for bb in required_bbs
     }
+    checked_cfg.unitary_flags = cfg.unitary_flags
 
     # Finally, run the linearity check
     from guppylang_internals.checker.linearity_checker import check_cfg_linearity
 
     linearity_checked_cfg = check_cfg_linearity(checked_cfg, func_name, globals)
+
+    from guppylang_internals.checker.unitary_checker import check_cfg_unitary
+
+    check_cfg_unitary(linearity_checked_cfg, cfg.unitary_flags)
+
     return linearity_checked_cfg
 
 

guppylang_internals/checker/core.py

@@ -47,7 +47,6 @@ from guppylang_internals.tys.ty import (
     NumericType,
     OpaqueType,
     StructType,
-    SumType,
     TupleType,
     Type,
 )
@@ -360,7 +359,7 @@ class Globals:
         match ty:
             case TypeDef() as type_defn:
                 pass
-            case BoundTypeVar() | ExistentialTypeVar() | SumType():
+            case BoundTypeVar() | ExistentialTypeVar():
                 return None
             case NumericType(kind):
                 match kind:

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/errors/wasm.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 from typing import ClassVar
 
-from guppylang_internals.diagnostic import Error
+from guppylang_internals.diagnostic import Error, Note
 from guppylang_internals.tys.ty import Type
 
 
@@ -13,10 +13,13 @@ class WasmError(Error):
 @dataclass(frozen=True)
 class FirstArgNotModule(WasmError):
     span_label: ClassVar[str] = (
-        "First argument to WASM function should be a reference to a WASM module."
-        " Found `{ty}` instead"
+        "First argument to WASM function should be a WASM module."
     )
-    ty: Type
+
+    @dataclass(frozen=True)
+    class GotOtherType(Note):
+        span_label: ClassVar[str] = "Found `{ty}` instead."
+        ty: Type
 
 
 @dataclass(frozen=True)

guppylang_internals/checker/expr_checker.py

@@ -43,6 +43,7 @@ from guppylang_internals.ast_util import (
 )
 from guppylang_internals.cfg.builder import is_tmp_var, tmp_vars
 from guppylang_internals.checker.core import (
+    ComptimeVariable,
     Context,
     DummyEvalDict,
     FieldAccess,
@@ -84,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 (
@@ -406,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:
@@ -453,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}`")
@@ -468,7 +484,7 @@ class ExprSynthesizer(AstVisitor[tuple[ast.expr, Type]]):
         # The only exception are attributes accesses that are generated during
         # desugaring (for example for iterators in `for` loops). Since those just
         # inherit the span of the sugared code, we could have line breaks there.
-        # See https://github.com/CQCL/guppylang/issues/1301
+        # See https://github.com/quantinuum/guppylang/issues/1301
         span = to_span(node)
         if span.start.line == span.end.line:
             attr_span = Span(span.end.shift_left(len(node.attr)), span.end)
@@ -503,12 +519,7 @@ class ExprSynthesizer(AstVisitor[tuple[ast.expr, Type]]):
             )
             # Make a closure by partially applying the `self` argument
             # TODO: Try to infer some type args based on `self`
-            result_ty = FunctionType(
-                func.ty.inputs[1:],
-                func.ty.output,
-                func.ty.input_names[1:] if func.ty.input_names else None,
-                func.ty.params,
-            )
+            result_ty = FunctionType(func.ty.inputs[1:], func.ty.output, func.ty.params)
             return with_loc(node, PartialApply(func=name, args=[node.value])), result_ty
         raise GuppyTypeError(AttributeNotFoundError(attr_span, ty, node.attr))
 
@@ -1035,7 +1046,14 @@ def check_place_assignable(
             exp_sig = FunctionType(
                 [
                     FuncInput(parent.ty, InputFlags.Inout),
-                    FuncInput(item.ty, InputFlags.NoFlags),
+                    FuncInput(
+                        # Due to potential coercions that were applied during the
+                        # `__getitem__` call (e.g. coercing a nat index to int), we're
+                        # not allowed to rely on `item.ty` here.
+                        # See https://github.com/CQCL/guppylang/issues/1356
+                        ExistentialTypeVar.fresh("T", True, True),
+                        InputFlags.NoFlags,
+                    ),
                     FuncInput(ty, InputFlags.Owned),
                 ],
                 NoneType(),
@@ -1072,6 +1090,8 @@ def check_comptime_arg(
     match arg:
         case ast.Constant(value=v):
             const = ConstValue(ty, v)
+        case PlaceNode(place=ComptimeVariable(ty=ty, static_value=v)):
+            const = ConstValue(ty, v)
         case GenericParamValue(param=const_param):
             const = const_param.to_bound().const
         case arg:

guppylang_internals/checker/func_checker.py

@@ -16,6 +16,7 @@ from guppylang_internals.cfg.builder import CFGBuilder
 from guppylang_internals.checker.cfg_checker import CheckedCFG, check_cfg
 from guppylang_internals.checker.core import Context, Globals, Place, Variable
 from guppylang_internals.checker.errors.generic import UnsupportedError
+from guppylang_internals.checker.unitary_checker import check_invalid_under_dagger
 from guppylang_internals.definition.common import DefId
 from guppylang_internals.definition.ty import TypeDef
 from guppylang_internals.diagnostic import Error, Help, Note
@@ -37,6 +38,7 @@ from guppylang_internals.tys.ty import (
     InputFlags,
     NoneType,
     Type,
+    UnitaryFlags,
     unify,
 )
 
@@ -134,12 +136,13 @@ def check_global_func_def(
     """Type checks a top-level function definition."""
     args = func_def.args.args
     returns_none = isinstance(ty.output, NoneType)
-    assert ty.input_names is not None
+    assert all(inp.name is not None for inp in ty.inputs)
 
-    cfg = CFGBuilder().build(func_def.body, returns_none, globals)
+    check_invalid_under_dagger(func_def, ty.unitary_flags)
+    cfg = CFGBuilder().build(func_def.body, returns_none, globals, ty.unitary_flags)
     inputs = [
-        Variable(x, inp.ty, loc, inp.flags, is_func_input=True)
-        for x, inp, loc in zip(ty.input_names, ty.inputs, args, strict=True)
+        Variable(cast(str, inp.name), inp.ty, loc, inp.flags, is_func_input=True)
+        for inp, loc in zip(ty.inputs, args, strict=True)
         # Comptime inputs are turned into generic args, so are not included here
         if InputFlags.Comptime not in inp.flags
     ]
@@ -150,7 +153,9 @@ def check_global_func_def(
 
 
 def check_nested_func_def(
-    func_def: NestedFunctionDef, bb: BB, ctx: Context
+    func_def: NestedFunctionDef,
+    bb: BB,
+    ctx: Context,
 ) -> CheckedNestedFunctionDef:
     """Type checks a local (nested) function definition."""
     func_ty = check_signature(func_def, ctx.globals)
@@ -194,10 +199,8 @@ def check_nested_func_def(
 
     # Construct inputs for checking the body CFG
     inputs = [v for v, _ in captured.values()] + [
-        Variable(x, inp.ty, func_def.args.args[i], inp.flags, is_func_input=True)
-        for i, (x, inp) in enumerate(
-            zip(func_ty.input_names, func_ty.inputs, strict=True)
-        )
+        Variable(cast(str, inp.name), inp.ty, arg, inp.flags, is_func_input=True)
+        for arg, inp in zip(func_def.args.args, func_ty.inputs, strict=True)
         # Comptime inputs are turned into generic args, so are not included here
         if InputFlags.Comptime not in inp.flags
     ]
@@ -238,7 +241,10 @@ def check_nested_func_def(
 
 
 def check_signature(
-    func_def: ast.FunctionDef, globals: Globals, def_id: DefId | None = None
+    func_def: ast.FunctionDef,
+    globals: Globals,
+    def_id: DefId | None = None,
+    unitary_flags: UnitaryFlags = UnitaryFlags.NoFlags,
 ) -> FunctionType:
     """Checks the signature of a function definition and returns the corresponding
     Guppy type.
@@ -286,7 +292,6 @@ def check_signature(
         assert isinstance(self_defn, TypeDef)
 
     inputs = []
-    input_names = []
     ctx = TypeParsingCtx(globals, param_var_mapping, allow_free_vars=True)
     for i, inp in enumerate(func_def.args.args):
         # Special handling for `self` arguments. Note that `__new__` is excluded here
@@ -300,13 +305,12 @@ def check_signature(
                 raise GuppyError(MissingArgAnnotationError(inp))
             input = parse_function_arg_annotation(ty_ast, inp.arg, ctx)
         inputs.append(input)
-        input_names.append(inp.arg)
     output = type_from_ast(func_def.returns, ctx)
     return FunctionType(
         inputs,
         output,
-        input_names,
         sorted(param_var_mapping.values(), key=lambda v: v.idx),
+        unitary_flags=unitary_flags,
     )
 
 

guppylang_internals/checker/linearity_checker.py

@@ -63,7 +63,6 @@ from guppylang_internals.nodes import (
     LocalCall,
     PartialApply,
     PlaceNode,
-    ResultExpr,
     StateResultExpr,
     SubscriptAccessAndDrop,
     TensorCall,
@@ -74,7 +73,6 @@ from guppylang_internals.tys.ty import (
     FuncInput,
     FunctionType,
     InputFlags,
-    NoneType,
     StructType,
     TupleType,
     Type,
@@ -451,13 +449,6 @@ class BBLinearityChecker(ast.NodeVisitor):
         self._visit_call_args(node.func_ty, node)
         self._reassign_inout_args(node.func_ty, node)
 
-    def visit_ResultExpr(self, node: ResultExpr) -> None:
-        ty = get_type(node.value)
-        flag = InputFlags.Inout if not ty.copyable else InputFlags.NoFlags
-        func_ty = FunctionType([FuncInput(ty, flag)], NoneType())
-        self._visit_call_args(func_ty, node)
-        self._reassign_inout_args(func_ty, node)
-
     def visit_StateResultExpr(self, node: StateResultExpr) -> None:
         self._visit_call_args(node.func_ty, node)
         self._reassign_inout_args(node.func_ty, node)
@@ -582,7 +573,7 @@ class BBLinearityChecker(ast.NodeVisitor):
             # can feed them through the loop. Note that we could also use non-local
             # edges, but we can't handle them in lower parts of the stack yet :/
             # TODO: Reinstate use of non-local edges.
-            #  See https://github.com/CQCL/guppylang/issues/963
+            #  See https://github.com/quantinuum/guppylang/issues/963
             gen.used_outer_places = []
             for x, use in inner_scope.used_parent.items():
                 place = inner_scope[x]
@@ -880,6 +871,7 @@ def check_cfg_linearity(
     result_cfg.maybe_ass_before = {
         checked[bb]: cfg.maybe_ass_before[bb] for bb in cfg.bbs
     }
+    result_cfg.unitary_flags = cfg.unitary_flags
     for bb in cfg.bbs:
         checked[bb].predecessors = [checked[pred] for pred in bb.predecessors]
         checked[bb].successors = [checked[succ] for succ in bb.successors]

guppylang_internals/checker/modifier_checker.py

@@ -71,7 +71,7 @@ def check_modified_block(
     # This name could be printed in error messages, for example,
     # when the linearity checker fails in the modifier body
     checked_cfg = check_cfg(cfg, inputs, NoneType(), {}, "__modified__()", globals)
-    func_ty = check_modified_block_signature(checked_cfg.input_tys)
+    func_ty = check_modified_block_signature(modified_block, checked_cfg.input_tys)
 
     checked_modifier = CheckedModifiedBlock(
         def_id,
@@ -94,9 +94,12 @@ def _set_inout_if_non_copyable(var: Variable) -> Variable:
         return var
 
 
-def check_modified_block_signature(input_tys: list[Type]) -> FunctionType:
+def check_modified_block_signature(
+    modified_block: ModifiedBlock, input_tys: list[Type]
+) -> FunctionType:
     """Check and create the signature of a function definition for a body
     of a `With` block."""
+    unitary_flags = modified_block.flags()
 
     func_ty = FunctionType(
         [
@@ -104,6 +107,7 @@ def check_modified_block_signature(input_tys: list[Type]) -> FunctionType:
             for t in input_tys
         ],
         NoneType(),
+        unitary_flags=unitary_flags,
     )
     return func_ty
 

guppylang_internals/checker/unitary_checker.py

@@ -0,0 +1,132 @@
+import ast
+
+from guppylang_internals.ast_util import find_nodes, get_type, loop_in_ast
+from guppylang_internals.checker.cfg_checker import CheckedBB, CheckedCFG
+from guppylang_internals.checker.core import Place, contains_subscript
+from guppylang_internals.checker.errors.generic import (
+    InvalidUnderDagger,
+    UnsupportedError,
+)
+from guppylang_internals.definition.value import CallableDef
+from guppylang_internals.engine import ENGINE
+from guppylang_internals.error import GuppyError, GuppyTypeError
+from guppylang_internals.nodes import (
+    AnyCall,
+    BarrierExpr,
+    GlobalCall,
+    LocalCall,
+    PlaceNode,
+    StateResultExpr,
+    TensorCall,
+)
+from guppylang_internals.tys.errors import UnitaryCallError
+from guppylang_internals.tys.qubit import contain_qubit_ty
+from guppylang_internals.tys.ty import FunctionType, UnitaryFlags
+
+
+def check_invalid_under_dagger(
+    fn_def: ast.FunctionDef, unitary_flags: UnitaryFlags
+) -> None:
+    """Check that there are no invalid constructs in a daggered CFG.
+    This checker checks the case the UnitaryFlags is given by
+    annotation (i.e., not inferred from `with dagger:`).
+    """
+    if UnitaryFlags.Dagger not in unitary_flags:
+        return
+
+    for stmt in fn_def.body:
+        loops = loop_in_ast(stmt)
+        if len(loops) != 0:
+            loop = next(iter(loops))
+            err = InvalidUnderDagger(loop, "Loop")
+            raise GuppyError(err)
+            # Note: sub-diagnostic for dagger context is not available here
+
+        found = find_nodes(
+            lambda n: isinstance(n, ast.Assign | ast.AnnAssign | ast.AugAssign),
+            stmt,
+            {ast.FunctionDef},
+        )
+        if len(found) != 0:
+            assign = next(iter(found))
+            err = InvalidUnderDagger(assign, "Assignment")
+            raise GuppyError(err)
+
+
+class BBUnitaryChecker(ast.NodeVisitor):
+    """AST visitor that checks whether the modifiers (dagger, control, power)
+    are applicable."""
+
+    flags: UnitaryFlags
+
+    def check(self, bb: CheckedBB[Place], unitary_flags: UnitaryFlags) -> None:
+        self.flags = unitary_flags
+        for stmt in bb.statements:
+            self.visit(stmt)
+
+    def _check_classical_args(self, args: list[ast.expr]) -> bool:
+        for arg in args:
+            self.visit(arg)
+            if contain_qubit_ty(get_type(arg)):
+                return False
+        return True
+
+    def _check_call(self, node: AnyCall, ty: FunctionType) -> None:
+        classic = self._check_classical_args(node.args)
+        flag_ok = self.flags in ty.unitary_flags
+        if not classic and not flag_ok:
+            raise GuppyTypeError(
+                UnitaryCallError(node, self.flags & (~ty.unitary_flags))
+            )
+
+    def visit_GlobalCall(self, node: GlobalCall) -> None:
+        func = ENGINE.get_parsed(node.def_id)
+        assert isinstance(func, CallableDef)
+        self._check_call(node, func.ty)
+
+    def visit_LocalCall(self, node: LocalCall) -> None:
+        func = get_type(node.func)
+        assert isinstance(func, FunctionType)
+        self._check_call(node, func)
+
+    def visit_TensorCall(self, node: TensorCall) -> None:
+        self._check_call(node, node.tensor_ty)
+
+    def visit_BarrierExpr(self, node: BarrierExpr) -> None:
+        # Barrier is always allowed
+        pass
+
+    def visit_StateResultExpr(self, node: StateResultExpr) -> None:
+        # StateResult is always allowed
+        pass
+
+    def _check_assign(self, node: ast.Assign | ast.AnnAssign | ast.AugAssign) -> None:
+        if UnitaryFlags.Dagger in self.flags:
+            raise GuppyError(InvalidUnderDagger(node, "Assignment"))
+        if node.value is not None:
+            self.visit(node.value)
+
+    def visit_AnnAssign(self, node: ast.AnnAssign) -> None:
+        self._check_assign(node)
+
+    def visit_Assign(self, node: ast.Assign) -> None:
+        self._check_assign(node)
+
+    def visit_AugAssign(self, node: ast.AugAssign) -> None:
+        self._check_assign(node)
+
+    def visit_PlaceNode(self, node: PlaceNode) -> None:
+        if UnitaryFlags.Dagger in self.flags and contains_subscript(node.place):
+            raise GuppyError(
+                UnsupportedError(node, "index access", True, "dagger context")
+            )
+
+
+def check_cfg_unitary(
+    cfg: CheckedCFG[Place],
+    unitary_flags: UnitaryFlags,
+) -> None:
+    """Checks that the given unitary flags are valid for a CFG."""
+    bb_checker = BBUnitaryChecker()
+    for bb in cfg.bbs:
+        bb_checker.check(bb, unitary_flags)

guppylang_internals/compiler/cfg_compiler.py

@@ -24,7 +24,7 @@ from guppylang_internals.compiler.core import (
 from guppylang_internals.compiler.expr_compiler import ExprCompiler
 from guppylang_internals.compiler.stmt_compiler import StmtCompiler
 from guppylang_internals.std._internal.compiler.tket_bool import OpaqueBool, read_bool
-from guppylang_internals.tys.ty import SumType, row_to_type, type_to_row
+from guppylang_internals.tys.ty import type_to_row
 
 
 def compile_cfg(
@@ -38,7 +38,7 @@ def compile_cfg(
     # TODO: This mutates the CFG in-place which leads to problems when trying to lower
     #  the same function to Hugr twice. For now we just check that the return vars
     #  haven't already been inserted, but we should figure out a better way to handle
-    #  this: https://github.com/CQCL/guppylang/issues/428
+    #  this: https://github.com/quantinuum/guppylang/issues/428
     if all(
         not is_return_var(v.name)
         for v in cfg.exit_bb.sig.input_row
@@ -52,7 +52,7 @@ def compile_cfg(
     # unreachable
     out_tys = [place.ty.to_hugr(ctx) for place in cfg.exit_bb.sig.input_row]
     # TODO: Use proper API for this once it's added in hugr-py:
-    #  https://github.com/CQCL/hugr/issues/1816
+    #  https://github.com/quantinuum/hugr/issues/1816
     builder._exit_op._cfg_outputs = out_tys
     builder.parent_op._outputs = out_tys
     builder.parent_node = builder.hugr._update_node_outs(
@@ -194,13 +194,14 @@ def choose_vars_for_tuple_sum(
     constructs a TupleSum value of type `Sum(#s1, #s2, ...)`.
     """
     assert all(v.ty.droppable for var_row in output_vars for v in var_row)
-    tys = [[v.ty for v in var_row] for var_row in output_vars]
-    sum_type = SumType([row_to_type(row) for row in tys]).to_hugr(dfg.ctx)
+    sum_type = ht.Sum(
+        [[v.ty.to_hugr(dfg.ctx) for v in var_row] for var_row in output_vars]
+    )
 
     # We pass all values into the conditional instead of relying on non-local edges.
     # This is because we can't handle them in lower parts of the stack yet :/
     # TODO: Reinstate use of non-local edges.
-    #  See https://github.com/CQCL/guppylang/issues/963
+    #  See https://github.com/quantinuum/guppylang/issues/963
     all_vars = {v.id: dfg[v] for var_row in output_vars for v in var_row}
     all_vars_wires = list(all_vars.values())
     all_vars_idxs = {x: i for i, x in enumerate(all_vars.keys())}