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

guppylang_internals/definition/function.py

@@ -31,6 +31,7 @@ from guppylang_internals.definition.common import (
     MonomorphizableDef,
     MonomorphizedDef,
     ParsableDef,
+    RawDef,
     UnknownSourceError,
 )
 from guppylang_internals.definition.metadata import GuppyMetadata, add_metadata
@@ -177,6 +178,7 @@ class CheckedFunctionDef(ParsedFunctionDef, MonomorphizableDef):
         module: DefinitionBuilder[OpVar],
         mono_args: "PartiallyMonomorphizedArgs",
         ctx: "CompilerContext",
+        parent_ty: "RawDef | None" = None,
     ) -> "CompiledFunctionDef":
         """Adds a Hugr `FuncDefn` node for the (partially) monomorphized function to the
         Hugr.
@@ -185,10 +187,15 @@ class CheckedFunctionDef(ParsedFunctionDef, MonomorphizableDef):
         access to the other compiled functions yet. The body is compiled later in
         `CompiledFunctionDef.compile_inner()`.
         """
+        if parent_ty is None:
+            hugr_func_name = self.name
+        else:
+            hugr_func_name = f"{parent_ty.name}.{self.name}"
+
         mono_ty = self.ty.instantiate_partial(mono_args)
         hugr_ty = mono_ty.to_hugr_poly(ctx)
         func_def = module.module_root_builder().define_function(
-            self.name, hugr_ty.body.input, hugr_ty.body.output, hugr_ty.params
+            hugr_func_name, hugr_ty.body.input, hugr_ty.body.output, hugr_ty.params
         )
         add_metadata(
             func_def,

guppylang_internals/definition/metadata.py

@@ -35,7 +35,7 @@ class GuppyMetadata:
 
     @classmethod
     def reserved_keys(cls) -> set[str]:
-        return {f.type.key for f in fields(GuppyMetadata)}
+        return {f.type.key for f in fields(GuppyMetadata)}  # type: ignore[union-attr]
 
 
 @dataclass(frozen=True)

guppylang_internals/definition/pytket_circuits.py

@@ -3,18 +3,17 @@ from dataclasses import dataclass, field
 from typing import Any, cast
 
 import hugr.build.function as hf
+from guppylang.defs import GuppyDefinition
 from hugr import Node, Wire, envelope, ops, val
 from hugr import tys as ht
 from hugr.build.dfg import DefinitionBuilder, OpVar
 from hugr.envelope import EnvelopeConfig
 from hugr.std.float import FLOAT_T
+from pytket.circuit import Circuit
 
 from guppylang_internals.ast_util import AstNode, has_empty_body, with_loc
 from guppylang_internals.checker.core import Context, Globals
-from guppylang_internals.checker.errors.comptime_errors import (
-    PytketSignatureMismatch,
-    TketNotInstalled,
-)
+from guppylang_internals.checker.errors.comptime_errors import PytketSignatureMismatch
 from guppylang_internals.checker.expr_checker import check_call, synthesize_call
 from guppylang_internals.checker.func_checker import (
     check_signature,
@@ -231,7 +230,7 @@ class ParsedPytketDef(CallableDef, CompilableDef):
                         )
                         lex_params = list(unpack_result)
                     param_order = cast(
-                        list[str], hugr_func.metadata["TKET1.input_parameters"]
+                        "list[str]", hugr_func.metadata["TKET1.input_parameters"]
                     )
                     lex_names = sorted(param_order)
                     name_to_param = dict(zip(lex_names, lex_params, strict=True))
@@ -369,69 +368,49 @@ class CompiledPytketDef(ParsedPytketDef, CompiledCallableDef, CompiledHugrNodeDe
 
 
 def _signature_from_circuit(
-    input_circuit: Any,
+    input_circuit: Circuit,
     defined_at: ToSpan | None,
     use_arrays: bool = False,
 ) -> FunctionType:
     """Helper function for inferring a function signature from a pytket circuit."""
     # May want to set proper unitary flags in the future.
-    try:
-        import pytket
-
-        if isinstance(input_circuit, pytket.circuit.Circuit):
-            try:
-                import tket  # type: ignore[import-untyped, import-not-found, unused-ignore]  # noqa: F401
-
-                from guppylang.defs import GuppyDefinition
-                from guppylang.std.angles import angle
-                from guppylang.std.quantum import qubit
-
-                assert isinstance(qubit, GuppyDefinition)
-                qubit_ty = cast(TypeDef, qubit.wrapped).check_instantiate([])
-
-                angle_defn = ENGINE.get_checked(angle.id)  # type: ignore[attr-defined]
-                assert isinstance(angle_defn, TypeDef)
-                angle_ty = angle_defn.check_instantiate([])
-
-                if use_arrays:
-                    inputs = [
-                        FuncInput(array_type(qubit_ty, q_reg.size), InputFlags.Inout)
-                        for q_reg in input_circuit.q_registers
-                    ]
-                    if len(input_circuit.free_symbols()) != 0:
-                        inputs.append(
-                            FuncInput(
-                                array_type(angle_ty, len(input_circuit.free_symbols())),
-                                InputFlags.NoFlags,
-                            )
-                        )
-                    outputs = [
-                        array_type(bool_type(), c_reg.size)
-                        for c_reg in input_circuit.c_registers
-                    ]
-                    circuit_signature = FunctionType(
-                        inputs,
-                        row_to_type(outputs),
-                    )
-                else:
-                    param_inputs = [
-                        FuncInput(angle_ty, InputFlags.NoFlags)
-                        for _ in range(len(input_circuit.free_symbols()))
-                    ]
-                    circuit_signature = FunctionType(
-                        [FuncInput(qubit_ty, InputFlags.Inout)] * input_circuit.n_qubits
-                        + param_inputs,
-                        row_to_type([bool_type()] * input_circuit.n_bits),
-                    )
-            except ImportError:
-                err = TketNotInstalled(defined_at)
-                err.add_sub_diagnostic(TketNotInstalled.InstallInstruction(None))
-                raise GuppyError(err) from None
-        else:
-            pass
-    except ImportError:
-        raise InternalGuppyError(
-            "Pytket error should have been caught earlier"
-        ) from None
+    from guppylang.std.angles import angle  # Avoid circular imports
+    from guppylang.std.quantum import qubit
+
+    assert isinstance(qubit, GuppyDefinition)
+    qubit_ty = cast("TypeDef", qubit.wrapped).check_instantiate([])
+
+    angle_defn = ENGINE.get_checked(angle.id)  # type: ignore[attr-defined]
+    assert isinstance(angle_defn, TypeDef)
+    angle_ty = angle_defn.check_instantiate([])
+
+    if use_arrays:
+        inputs = [
+            FuncInput(array_type(qubit_ty, q_reg.size), InputFlags.Inout)
+            for q_reg in input_circuit.q_registers
+        ]
+        if len(input_circuit.free_symbols()) != 0:
+            inputs.append(
+                FuncInput(
+                    array_type(angle_ty, len(input_circuit.free_symbols())),
+                    InputFlags.NoFlags,
+                )
+            )
+        outputs = [
+            array_type(bool_type(), c_reg.size) for c_reg in input_circuit.c_registers
+        ]
+        circuit_signature = FunctionType(
+            inputs,
+            row_to_type(outputs),
+        )
     else:
-        return circuit_signature
+        param_inputs = [
+            FuncInput(angle_ty, InputFlags.NoFlags)
+            for _ in range(len(input_circuit.free_symbols()))
+        ]
+        circuit_signature = FunctionType(
+            [FuncInput(qubit_ty, InputFlags.Inout)] * input_circuit.n_qubits
+            + param_inputs,
+            row_to_type([bool_type()] * input_circuit.n_bits),
+        )
+    return circuit_signature

guppylang_internals/definition/value.py

@@ -55,7 +55,7 @@ class CallableDef(ValueDef):
         raise RuntimeError("Guppy functions can only be called in a Guppy context")
 
 
-class CompiledCallableDef(CallableDef, CompiledValueDef):
+class CompiledCallableDef(CallableDef, CompiledValueDef):  # type: ignore[misc, unused-ignore]
     """Abstract base class a global module-level function."""
 
     ty: FunctionType

guppylang_internals/definition/wasm.py

@@ -38,9 +38,9 @@ class RawWasmFunctionDef(RawCustomFunctionDef):
     def sanitise_type(self, loc: AstNode, fun_ty: FunctionType) -> None:
         # Place to highlight in error messages
         match fun_ty.inputs:
-            case [FuncInput(ty=ty, flags=InputFlags.Inout), *args] if wasm_module_name(
-                ty
-            ) is not None:
+            case [FuncInput(ty=ty, flags=InputFlags.Inout), *args] if (
+                wasm_module_name(ty) is not None
+            ):
                 for inp in args:
                     if not self.is_type_wasmable(inp.ty):
                         raise GuppyError(UnWasmableType(loc, inp.ty))

guppylang_internals/diagnostic.py

@@ -384,9 +384,25 @@ class DiagnosticsRenderer:
         if is_primary or print_pad_line:
             render_line("")
 
-        # Grab all lines we want to display and remove excessive leading whitespace
+        # Grab all lines we want to display
         prefix_lines = min(prefix_lines, span.start.line - 1)
         all_lines = self.source.span_lines(span, prefix_lines)
+
+        # Convert leading tab characters into four whitespaces each (see PEP 8)
+        for i, line in enumerate(all_lines):
+            line_no_tabs = line.lstrip("\t")
+            num_tabs = len(line) - len(line_no_tabs)
+            all_lines[i] = " " * (num_tabs * 4) + line_no_tabs
+            # Shift span locations, accounting for incorporated \t
+            new_start = span.start
+            new_end = span.end
+            if i == prefix_lines:  # Line is the first line in the span
+                new_start = span.start.shift_right(num_tabs * 3)
+            if i == len(all_lines) - 1:  # Line is the last line in the span
+                new_end = span.end.shift_right(num_tabs * 3)
+            span = Span(new_start or span.start, new_end)
+
+        # Remove excessive leading whitespace
         leading_whitespace = min(len(line) - len(line.lstrip()) for line in all_lines)
         if leading_whitespace > self.MAX_LEADING_WHITESPACE:
             remove = leading_whitespace - self.OPTIMAL_LEADING_WHITESPACE

guppylang_internals/engine.py

@@ -3,14 +3,10 @@ from enum import Enum
 from types import FrameType
 from typing import TYPE_CHECKING
 
+import hugr
 import hugr.build.function as hf
-import hugr.std.collections.array
-import hugr.std.float
-import hugr.std.int
-import hugr.std.logic
-import hugr.std.prelude
 from hugr import ops
-from hugr.ext import Extension
+from hugr.ext import Extension, ExtensionRegistry
 from hugr.package import ModulePointer, Package
 
 import guppylang_internals
@@ -150,11 +146,52 @@ class CompilationEngine:
     types_to_check_worklist: dict[DefId, ParsedDef]
     to_check_worklist: dict[DefId, ParsedDef]
 
+    # Cached compilation infrastructure (lazy-initialized, program-independent)
+    _base_packaged_extensions: list[Extension] | None = None
+    _base_resolve_registry: ExtensionRegistry | None = None
+
     def __init__(self) -> None:
         """Resets the compilation cache."""
         self.reset()
         self.additional_extensions = []
 
+    @staticmethod
+    def _get_base_packaged_extensions() -> list[Extension]:
+        """Get the base list of packaged extensions (cached at class level)."""
+        if CompilationEngine._base_packaged_extensions is None:
+            from guppylang_internals.std._internal.compiler.tket_exts import (
+                TKET_EXTENSIONS,
+            )
+
+            CompilationEngine._base_packaged_extensions = [
+                *TKET_EXTENSIONS,
+                guppylang_internals.compiler.hugr_extension.EXTENSION,  # type: ignore[attr-defined]
+            ]
+        return CompilationEngine._base_packaged_extensions
+
+    @staticmethod
+    def _get_base_resolve_registry() -> ExtensionRegistry:
+        """Get the base resolve registry with standard extensions.
+
+        Cached at class level.
+        """
+        if CompilationEngine._base_resolve_registry is None:
+            base_extensions = CompilationEngine._get_base_packaged_extensions()
+            registry = ExtensionRegistry()
+            for ext in [
+                *base_extensions,
+                hugr.std.prelude.PRELUDE_EXTENSION,
+                hugr.std.collections.array.EXTENSION,
+                hugr.std.float.FLOAT_OPS_EXTENSION,
+                hugr.std.float.FLOAT_TYPES_EXTENSION,
+                hugr.std.int.INT_OPS_EXTENSION,
+                hugr.std.int.INT_TYPES_EXTENSION,
+                hugr.std.logic.EXTENSION,
+            ]:
+                registry.register_updated(ext)
+            CompilationEngine._base_resolve_registry = registry
+        return CompilationEngine._base_resolve_registry
+
     def reset(self) -> None:
         """Resets the compilation cache."""
         self.parsed = {}
@@ -264,40 +301,56 @@ class CompilationEngine:
             # loosened after https://github.com/quantinuum/hugr/issues/2501 is fixed
             graph.hugr.entrypoint = compiled_def.hugr_node
 
-        # TODO: Currently the list of extensions is manually managed by the user.
-        #  We should compute this dynamically from the imported dependencies instead.
-        #
-        # The hugr prelude and std_extensions are implicit.
-        from guppylang_internals.std._internal.compiler.tket_exts import TKET_EXTENSIONS
+        # Use cached base extensions and registry, only add additional extensions
+        base_extensions = self._get_base_packaged_extensions()
+        packaged_extensions = [*base_extensions, *self.additional_extensions]
 
-        extensions = [
-            *TKET_EXTENSIONS,
-            guppylang_internals.compiler.hugr_extension.EXTENSION,
-            *self.additional_extensions,
-        ]
-        # TODO replace with computed extensions after https://github.com/quantinuum/guppylang/issues/550
-        all_used_extensions = [
-            *extensions,
-            hugr.std.prelude.PRELUDE_EXTENSION,
-            hugr.std.collections.array.EXTENSION,
-            hugr.std.float.FLOAT_OPS_EXTENSION,
-            hugr.std.float.FLOAT_TYPES_EXTENSION,
-            hugr.std.int.INT_OPS_EXTENSION,
-            hugr.std.int.INT_TYPES_EXTENSION,
-            hugr.std.logic.EXTENSION,
-        ]
-        graph.hugr.module_root.metadata[CoreMetadataKeys.USED_EXTENSIONS.value] = [
+        # Build resolve registry: start with cached base, add any additional
+        if self.additional_extensions:
+            from copy import deepcopy
+
+            resolve_registry = deepcopy(self._get_base_resolve_registry())
+            for ext in self.additional_extensions:
+                resolve_registry.register_updated(ext)
+        else:
+            resolve_registry = self._get_base_resolve_registry()
+
+        # Compute used extensions dynamically from the HUGR.
+        used_extensions_result = graph.hugr.used_extensions(
+            resolve_from=resolve_registry
+        )
+
+        # Set metadata for used extensions
+        used_exts_meta = [
             {
                 "name": ext.name,
                 "version": str(ext.version),
             }
-            for ext in all_used_extensions
+            for ext in used_extensions_result.used_extensions.extensions.values()
         ]
+        # Add unresolved extensions as well, but we only have the names
+        used_exts_meta.extend(
+            {
+                "name": ext,
+            }
+            for ext in used_extensions_result.unresolved_extensions
+        )
+        graph.hugr.module_root.metadata[CoreMetadataKeys.USED_EXTENSIONS.value] = (
+            used_exts_meta
+        )
         graph.hugr.module_root.metadata[CoreMetadataKeys.GENERATOR.value] = {
             "name": "guppylang",
             "version": guppylang_internals.__version__,
         }
-        return ModulePointer(Package(modules=[graph.hugr], extensions=extensions), 0)
+        # only package used extensions
+        packaged_extensions = [
+            ext
+            for ext in packaged_extensions
+            if ext.name in used_extensions_result.ids()
+        ]
+        return ModulePointer(
+            Package(modules=[graph.hugr], extensions=packaged_extensions), 0
+        )
 
 
 ENGINE: CompilationEngine = CompilationEngine()

guppylang_internals/error.py

@@ -104,4 +104,4 @@ def pretty_errors(f: FuncT) -> FuncT:
         with exception_hook(hook):
             return f(*args, **kwargs)
 
-    return cast(FuncT, pretty_errors_wrapped)
+    return cast("FuncT", pretty_errors_wrapped)