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

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):

guppylang_internals/tys/printing.py

@@ -11,7 +11,6 @@ from guppylang_internals.tys.ty import (
     NumericType,
     OpaqueType,
     StructType,
-    SumType,
     TupleType,
     Type,
 )
@@ -122,11 +121,6 @@ class TypePrinter:
         args = ", ".join(self._visit(arg, True) for arg in ty.args)
         return f"({args})"
 
-    @_visit.register
-    def _visit_SumType(self, ty: SumType, inside_row: bool) -> str:
-        args = ", ".join(self._visit(arg, True) for arg in ty.args)
-        return f"Sum[{args}]"
-
     @_visit.register
     def _visit_NoneType(self, ty: NoneType, inside_row: bool) -> str:
         return "None"
@@ -168,7 +162,7 @@ def signature_to_str(name: str, sig: FunctionType) -> str:
     assert sig.input_names is not None
     s = f"def {name}("
     s += ", ".join(
-        f"{name}: {inp.ty}{TypePrinter._print_flags(inp.flags)}"
-        for name, inp in zip(sig.input_names, sig.inputs, strict=True)
+        f"{inp.name}: {inp.ty}{TypePrinter._print_flags(inp.flags)}"
+        for inp in sig.inputs
     )
     return s + ") -> " + str(sig.output)

guppylang_internals/tys/qubit.py

@@ -1,8 +1,10 @@
 import functools
-from typing import cast
+from typing import Any, cast
 
 from guppylang_internals.definition.ty import TypeDef
-from guppylang_internals.tys.ty import Type
+from guppylang_internals.tys.arg import TypeArg
+from guppylang_internals.tys.common import Visitor
+from guppylang_internals.tys.ty import OpaqueType, Type
 
 
 @functools.cache
@@ -25,3 +27,36 @@ def is_qubit_ty(ty: Type) -> bool:
     before qubit types are registered.
     """
     return ty == qubit_ty()
+
+
+class QubitFinder(Visitor):
+    """Type visitor that checks if a type contains the qubit type."""
+
+    class FoundFlag(Exception):
+        pass
+
+    @functools.singledispatchmethod
+    def visit(self, ty: Any) -> bool:  # type: ignore[override]
+        return False
+
+    @visit.register
+    def _visit_OpaqueType(self, ty: OpaqueType) -> bool:
+        if is_qubit_ty(ty):
+            raise self.FoundFlag
+        return False
+
+    @visit.register
+    def _visit_TypeArg(self, arg: TypeArg) -> bool:
+        arg.ty.visit(self)
+        return True
+
+
+def contain_qubit_ty(ty: Type) -> bool:
+    """Checks if the given type contains the qubit type."""
+    finder = QubitFinder()
+    try:
+        ty.visit(finder)
+    except QubitFinder.FoundFlag:
+        return True
+    else:
+        return False

guppylang_internals/tys/ty.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from enum import Enum, Flag, auto
 from functools import cached_property, total_ordering
 from typing import TYPE_CHECKING, ClassVar, TypeAlias, cast
@@ -369,6 +369,21 @@ class InputFlags(Flag):
     Comptime = auto()
 
 
+class UnitaryFlags(Flag):
+    """Flags that can be set on functions to indicate their unitary properties.
+
+    The flags indicate under which conditions a function can be used
+    in a unitary context.
+    """
+
+    NoFlags = 0
+    Control = auto()
+    Dagger = auto()
+    Power = auto()
+
+    Unitary = Control | Dagger | Power
+
+
 @dataclass(frozen=True)
 class FuncInput:
     """A single input of a function type."""
@@ -376,6 +391,10 @@ class FuncInput:
     ty: "Type"
     flags: InputFlags
 
+    #: Name of this input, or `None` if it is an unnamed argument (e.g. inside a
+    #: `Callable`). We use `compare=False` because names are not visible to the caller.
+    name: str | None = field(default=None, compare=False)
+
 
 @dataclass(frozen=True, init=False)
 class FunctionType(ParametrizedTypeBase):
@@ -384,7 +403,6 @@ class FunctionType(ParametrizedTypeBase):
     inputs: Sequence[FuncInput]
     output: "Type"
     params: Sequence[Parameter]
-    input_names: Sequence[str] | None
     comptime_args: Sequence[ConstArg]
 
     args: Sequence[Argument] = field(init=False)
@@ -394,13 +412,15 @@ class FunctionType(ParametrizedTypeBase):
     intrinsically_droppable: bool = field(default=True, init=True)
     hugr_bound: ht.TypeBound = field(default=ht.TypeBound.Copyable, init=False)
 
+    unitary_flags: UnitaryFlags = field(default=UnitaryFlags.NoFlags, init=True)
+
     def __init__(
         self,
         inputs: Sequence[FuncInput],
         output: "Type",
-        input_names: Sequence[str] | None = None,
         params: Sequence[Parameter] | None = None,
         comptime_args: Sequence[ConstArg] | None = None,
+        unitary_flags: UnitaryFlags = UnitaryFlags.NoFlags,
     ) -> None:
         # We need a custom __init__ to set the args
         args: list[Argument] = [TypeArg(inp.ty) for inp in inputs]
@@ -416,12 +436,19 @@ class FunctionType(ParametrizedTypeBase):
             ]
         args += comptime_args
 
+        # Either all inputs must have unique names, or none of them have names
+        names = {inp.name for inp in inputs if inp.name is not None}
+        if len(names) not in (0, len(inputs)):
+            raise InternalGuppyError(
+                "Tried to construct FunctionType with invalid input names"
+            )
+
         object.__setattr__(self, "args", args)
         object.__setattr__(self, "comptime_args", comptime_args)
         object.__setattr__(self, "inputs", inputs)
         object.__setattr__(self, "output", output)
-        object.__setattr__(self, "input_names", input_names or [])
         object.__setattr__(self, "params", params)
+        object.__setattr__(self, "unitary_flags", unitary_flags)
 
     @property
     def parametrized(self) -> bool:
@@ -436,6 +463,16 @@ class FunctionType(ParametrizedTypeBase):
             return set()
         return super().bound_vars
 
+    @cached_property
+    def input_names(self) -> Sequence[str] | None:
+        """Names of all inputs or `None` if there are unnamed inputs."""
+        names: list[str] = []
+        for inp in self.inputs:
+            if inp.name is None:
+                return None
+            names.append(inp.name)
+        return names
+
     def cast(self) -> "Type":
         """Casts an implementor of `TypeBase` into a `Type`."""
         return self
@@ -494,12 +531,8 @@ class FunctionType(ParametrizedTypeBase):
     def transform(self, transformer: Transformer) -> "Type":
         """Accepts a transformer on this type."""
         return transformer.transform(self) or FunctionType(
-            [
-                FuncInput(inp.ty.transform(transformer), inp.flags)
-                for inp in self.inputs
-            ],
+            [replace(inp, ty=inp.ty.transform(transformer)) for inp in self.inputs],
             self.output.transform(transformer),
-            self.input_names,
             self.params,
         )
 
@@ -529,9 +562,8 @@ class FunctionType(ParametrizedTypeBase):
 
         inst = Instantiator(full_inst)
         return FunctionType(
-            [FuncInput(inp.ty.transform(inst), inp.flags) for inp in self.inputs],
+            [replace(inp, ty=inp.ty.transform(inst)) for inp in self.inputs],
             self.output.transform(inst),
-            self.input_names,
             remaining_params,
             # Comptime type arguments also need to be instantiated
             comptime_args=[
@@ -548,6 +580,18 @@ class FunctionType(ParametrizedTypeBase):
         exs = [param.to_existential() for param in self.params]
         return self.instantiate([arg for arg, _ in exs]), [var for _, var in exs]
 
+    def with_unitary_flags(self, flags: UnitaryFlags) -> "FunctionType":
+        """Returns a copy of this function type with the specified unitary flags."""
+        # N.B. we can't use `dataclasses.replace` here since `FunctionType` has a custom
+        # constructor
+        return FunctionType(
+            self.inputs,
+            self.output,
+            self.params,
+            self.comptime_args,
+            flags,
+        )
+
 
 @dataclass(frozen=True, init=False)
 class TupleType(ParametrizedTypeBase):
@@ -592,53 +636,6 @@ class TupleType(ParametrizedTypeBase):
         )
 
 
-@dataclass(frozen=True, init=False)
-class SumType(ParametrizedTypeBase):
-    """Type of sums.
-
-    Note that this type is only used internally when constructing the Hugr. Users cannot
-    write down this type.
-    """
-
-    element_types: Sequence["Type"]
-
-    def __init__(self, element_types: Sequence["Type"]) -> None:
-        # We need a custom __init__ to set the args
-        args = [TypeArg(ty) for ty in element_types]
-        object.__setattr__(self, "args", args)
-        object.__setattr__(self, "element_types", element_types)
-
-    @property
-    def intrinsically_copyable(self) -> bool:
-        """Whether objects of this type can be implicitly copied."""
-        return True
-
-    @property
-    def intrinsically_droppable(self) -> bool:
-        """Whether objects of this type can be dropped."""
-        return True
-
-    def cast(self) -> "Type":
-        """Casts an implementor of `TypeBase` into a `Type`."""
-        return self
-
-    def to_hugr(self, ctx: ToHugrContext) -> ht.Sum:
-        """Computes the Hugr representation of the type."""
-        rows = [type_to_row(ty) for ty in self.element_types]
-        if all(len(row) == 0 for row in rows):
-            return ht.UnitSum(size=len(rows))
-        elif len(rows) == 1:
-            return ht.Tuple(*row_to_hugr(rows[0], ctx))
-        else:
-            return ht.Sum(variant_rows=rows_to_hugr(rows, ctx))
-
-    def transform(self, transformer: Transformer) -> "Type":
-        """Accepts a transformer on this type."""
-        return transformer.transform(self) or SumType(
-            [ty.transform(transformer) for ty in self.element_types]
-        )
-
-
 @dataclass(frozen=True)
 class OpaqueType(ParametrizedTypeBase):
     """Type that is directly backed by a Hugr opaque type.
@@ -727,9 +724,8 @@ class StructType(ParametrizedTypeBase):
 
 
 #: The type of parametrized Guppy types.
-ParametrizedType: TypeAlias = (
-    FunctionType | TupleType | SumType | OpaqueType | StructType
-)
+ParametrizedType: TypeAlias = FunctionType | TupleType | OpaqueType | StructType
+
 
 #: The type of Guppy types.
 #:
@@ -811,8 +807,6 @@ def unify(s: Type | Const, t: Type | Const, subst: "Subst | None") -> "Subst | N
             return _unify_args(s, t, subst)
         case TupleType() as s, TupleType() as t:
             return _unify_args(s, t, subst)
-        case SumType() as s, SumType() as t:
-            return _unify_args(s, t, subst)
         case OpaqueType() as s, OpaqueType() as t if s.defn == t.defn:
             return _unify_args(s, t, subst)
         case StructType() as s, StructType() as t if s.defn == t.defn:
@@ -881,6 +875,8 @@ def function_tensor_signature(tys: list[FunctionType]) -> FunctionType:
     outputs: list[Type] = []
     for fun_ty in tys:
         assert not fun_ty.parametrized
-        inputs.extend(fun_ty.inputs)
+        # Forget the function input names since they might be non-unique across the
+        # tensored functions
+        inputs.extend([replace(inp, name=None) for inp in fun_ty.inputs])
         outputs.extend(type_to_row(fun_ty.output))
     return FunctionType(inputs, row_to_type(outputs))

guppylang_internals/wasm_util.py

@@ -0,0 +1,129 @@
+from dataclasses import dataclass
+from typing import ClassVar
+
+import wasmtime as wt
+
+from guppylang_internals.diagnostic import Error, Note
+from guppylang_internals.tys.ty import (
+    FuncInput,
+    FunctionType,
+    InputFlags,
+    NoneType,
+    NumericType,
+    Type,
+)
+
+
+# The thing to be imported elsewhere
+@dataclass
+class ConcreteWasmModule:
+    filename: str
+    # Function names in order for looking up by index
+    functions: list[str]
+    function_sigs: dict[str, FunctionType | str]
+
+
+@dataclass(frozen=True)
+class WasmSignatureError(Error):
+    title: ClassVar[str] = (
+        "Invalid signature for @wasm function `{fn_name}`\n"
+        "in wasm file:\n`{filename}`"
+    )
+    fn_name: str
+    filename: str
+
+    @dataclass(frozen=True)
+    class Message(Note):
+        message = "{msg}"
+        msg: str
+
+
+@dataclass(frozen=True)
+class WasmFileNotFound(Error):
+    title: ClassVar[str] = "Wasm file `{file}` not found"
+    file: str
+
+
+@dataclass(frozen=True)
+class WasmFunctionNotInFile(Error):
+    title: ClassVar[str] = (
+        "Declared wasm function `{function}` isn't exported by wasm file"
+    )
+    function: str
+
+    @dataclass(frozen=True)
+    class WasmFileNote(Note):
+        message: ClassVar[str] = "Wasm file:\n`{filename}`"
+        filename: str
+
+
+@dataclass(frozen=True)
+class WasmSigMismatchError(Error):
+    title: ClassVar[str] = "Wasm signature mismatch"
+    span_label: ClassVar[str] = (
+        "Signature of wasm function didn't match that in provided wasm file"
+    )
+
+    @dataclass(frozen=True)
+    class Declaration(Note):
+        message: ClassVar[str] = "Declared signature: {declared}"
+        declared: str
+
+    @dataclass(frozen=True)
+    class Actual(Note):
+        message: ClassVar[str] = "Signature in wasm:  {actual}"
+        actual: str
+
+
+def decode_type(ty: wt.ValType) -> Type | None:
+    if ty == wt.ValType.i64():
+        return NumericType(NumericType.Kind.Int)
+    elif ty == wt.ValType.f64():
+        return NumericType(NumericType.Kind.Float)
+    else:
+        return None
+
+
+def decode_sig(
+    params: list[wt.ValType], output: wt.ValType | None
+) -> FunctionType | str:
+    # Function args in wasm are called "params"
+    my_params: list[FuncInput] = []
+    for p in params:
+        if ty := decode_type(p):
+            my_params.append(FuncInput(ty, flags=InputFlags.NoFlags))
+        else:
+            return f"Unsupported input type: {p}"
+    if output:
+        if ty := decode_type(output):
+            return FunctionType(my_params, ty)
+        else:
+            return f"Unsupported output type: {output}"
+    else:
+        return FunctionType(my_params, NoneType())
+
+
+def decode_wasm_functions(filename: str) -> ConcreteWasmModule:
+    engine = wt.Engine()
+    mod = wt.Module.from_file(engine, filename)
+
+    functions: list[str] = []
+    function_sigs: dict[str, FunctionType | str] = {}
+    for fn in mod.exports:
+        functions.append(fn.name)
+        match fn.type:
+            case wt.FuncType() as fun_ty:
+                match fun_ty.results:
+                    case []:
+                        data = decode_sig(fun_ty.params, None)
+                    case [output]:
+                        data = decode_sig(fun_ty.params, output)
+                    case _multi:
+                        data = (
+                            f"Multiple output types unsupported in function `{fn.name}`"
+                        )
+            case _:
+                data = f"`{fn.name}` is not exported as a function"
+        function_sigs[fn.name] = data
+
+    return ConcreteWasmModule(filename, functions, function_sigs)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guppylang-internals
-Version: 0.25.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,9 +219,10 @@ 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
 Provides-Extra: pytket
 Requires-Dist: pytket>=1.34; extra == 'pytket'
 Description-Content-Type: text/markdown
@@ -244,10 +245,10 @@ pip install guppylang-internals
 
 See [DEVELOPMENT.md] information on how to develop and contribute to this package.
 
-  [DEVELOPMENT.md]: https://github.com/CQCL/guppylang/blob/main/DEVELOPMENT.md
+  [DEVELOPMENT.md]: https://github.com/quantinuum/guppylang/blob/main/DEVELOPMENT.md
 
 ## License
 
 This project is licensed under Apache License, Version 2.0 ([LICENCE][] or http://www.apache.org/licenses/LICENSE-2.0).
 
-  [LICENCE]: https://github.com/CQCL/guppylang/blob/main/LICENCE
+  [LICENCE]: https://github.com/quantinuum/guppylang/blob/main/LICENCE