guppylang-internals 0.26.0__tar.gz → 0.27.0__tar.gz

{guppylang_internals-0.26.0 → guppylang_internals-0.27.0}/CHANGELOG.md

@@ -3,6 +3,36 @@
 First release of `guppylang_internals` package containing refactored out internal components
 from `guppylang`.
 
+## [0.27.0](https://github.com/Quantinuum/guppylang/compare/guppylang-internals-v0.26.0...guppylang-internals-v0.27.0) (2026-01-08)
+
+
+### ⚠ BREAKING CHANGES
+
+* The first argument to `add_unitarity_metadata` is now named `node`
+instead of `func`, since its type was raised to allow for more HUGR
+nodes to be fed. Migration is trivial. 
+* `DiagnosticsRenderer.PREFIX_CONTEXT_LINES` constant has been removed.
+
+### Features
+
+* Add qubit hints on Guppy functions, allowing elision when building emulators ([#1378](https://github.com/Quantinuum/guppylang/issues/1378)) ([b7f10c6](https://github.com/Quantinuum/guppylang/commit/b7f10c6798aa20841fae844084d8a1606661fd7b)), closes [#1297](https://github.com/Quantinuum/guppylang/issues/1297)
+* Add unsafe array take and put operations ([#1165](https://github.com/Quantinuum/guppylang/issues/1165)) ([7f342e7](https://github.com/Quantinuum/guppylang/commit/7f342e788e2f179382bab46dcc7e69a24dd64de3))
+* **internals:** update to hugr-py 0.15 ([#1418](https://github.com/Quantinuum/guppylang/issues/1418)) ([cf970ba](https://github.com/Quantinuum/guppylang/commit/cf970ba7403a126fbd5d2fd53445e65270581df4))
+
+
+### Bug Fixes
+
+* Add a line break for printing WASM files ([#1386](https://github.com/Quantinuum/guppylang/issues/1386)) ([495aba5](https://github.com/Quantinuum/guppylang/commit/495aba5b9bb2218224193c7b2da2c5586744505a))
+* added deepcopy in `OverloadedFunctionDef.{check_call,synthesize_call}` ([#1426](https://github.com/Quantinuum/guppylang/issues/1426)) ([9be6fef](https://github.com/Quantinuum/guppylang/commit/9be6fefcdfb9fc9eb1025774d2dd2727b3e719b1))
+* **checker:** handle imported ParamDef with aliases in expr_checker ([#1385](https://github.com/Quantinuum/guppylang/issues/1385)) ([f2838a3](https://github.com/Quantinuum/guppylang/commit/f2838a34a315599c5b46eae92b72e9758e428a16))
+* Convert symbolic pytket circuits angle inputs into rotations ([#1425](https://github.com/Quantinuum/guppylang/issues/1425)) ([4724d90](https://github.com/Quantinuum/guppylang/commit/4724d9039d8dffae8fd939f62ae80ec307d8918a))
+* Ensure errors from `[@wasm](https://github.com/wasm)_module` are rendered correctly ([#1398](https://github.com/Quantinuum/guppylang/issues/1398)) ([a6a539f](https://github.com/Quantinuum/guppylang/commit/a6a539fe07cc94f4a788fef506969e4c9027faee)), closes [#1397](https://github.com/Quantinuum/guppylang/issues/1397)
+* Fix another wasm diagnostics rendering issue ([#1399](https://github.com/Quantinuum/guppylang/issues/1399)) ([6604175](https://github.com/Quantinuum/guppylang/commit/660417542f2b36c387e73765f8647c11cd3d1a7b))
+* Fix Hugr generation for tuples in `Result` and `Either` ([#1395](https://github.com/Quantinuum/guppylang/issues/1395)) ([f8b0d47](https://github.com/Quantinuum/guppylang/commit/f8b0d47eb275aae3f5ba804dfeb3640c4a3baef6)), closes [#1388](https://github.com/Quantinuum/guppylang/issues/1388)
+* improve diagnostics rendering ([#1382](https://github.com/Quantinuum/guppylang/issues/1382)) ([e7ce7f6](https://github.com/Quantinuum/guppylang/commit/e7ce7f6d1a4f2b12ff680a6e54dae96637c5fa92))
+* Stop parsing entrypoints twice ([#1410](https://github.com/Quantinuum/guppylang/issues/1410)) ([4a167e5](https://github.com/Quantinuum/guppylang/commit/4a167e5642cedc8f47ad027ed08483caa1558830))
+* Support comptime expressions in generic argument applications ([#1409](https://github.com/Quantinuum/guppylang/issues/1409)) ([c1aad34](https://github.com/Quantinuum/guppylang/commit/c1aad346adb15e3636e5586987422d74e36189a1)), closes [#1087](https://github.com/Quantinuum/guppylang/issues/1087)
+
 ## [0.26.0](https://github.com/Quantinuum/guppylang/compare/guppylang-internals-v0.25.0...guppylang-internals-v0.26.0) (2025-12-11)
 
 

{guppylang_internals-0.26.0 → guppylang_internals-0.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guppylang-internals
-Version: 0.26.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,7 +219,7 @@ 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

{guppylang_internals-0.26.0 → guppylang_internals-0.27.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "guppylang-internals"
-version = "0.26.0"
+version = "0.27.0"
 requires-python = ">=3.10,<4"
 description = "Compiler internals for `guppylang` package."
 license = { file = "LICENCE" }
@@ -35,7 +35,7 @@ classifiers = [
 dependencies = [
     "typing-extensions >=4.9.0,<5",
     "tket-exts ~= 0.12.0",
-    "hugr ~= 0.14.1",
+    "hugr ~= 0.15.0",
     "wasmtime ~= v38.0.0",
 ]
 

{guppylang_internals-0.26.0 → guppylang_internals-0.27.0}/src/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.26.0"
+__version__ = "0.27.0"

{guppylang_internals-0.26.0 → guppylang_internals-0.27.0}/src/guppylang_internals/cfg/builder.py

@@ -668,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-0.26.0 → guppylang_internals-0.27.0}/src/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-0.26.0 → guppylang_internals-0.27.0}/src/guppylang_internals/checker/expr_checker.py

@@ -85,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 (
@@ -407,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:
@@ -454,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}`")

{guppylang_internals-0.26.0 → guppylang_internals-0.27.0}/src/guppylang_internals/compiler/expr_compiler.py

@@ -325,14 +325,7 @@ class ExprCompiler(CompilerBase, AstVisitor[Wire]):
 
     def _pack_returns(self, returns: Sequence[Wire], return_ty: Type) -> Wire:
         """Groups function return values into a tuple"""
-        if isinstance(return_ty, TupleType | NoneType) and not return_ty.preserve:
-            types = type_to_row(return_ty)
-            assert len(returns) == len(types)
-            return self._pack_tuple(returns, types)
-        assert (
-            len(returns) == 1
-        ), f"Expected a single return value. Got {returns}. return type {return_ty}"
-        return returns[0]
+        return pack_returns(returns, return_ty, self.builder, self.ctx)
 
     def _update_inout_ports(
         self,
@@ -760,6 +753,35 @@ def expr_to_row(expr: ast.expr) -> list[ast.expr]:
     return expr.elts if isinstance(expr, ast.Tuple) else [expr]
 
 
+def pack_returns(
+    returns: Sequence[Wire],
+    return_ty: Type,
+    builder: DfBase[ops.DfParentOp],
+    ctx: CompilerContext,
+) -> Wire:
+    """Groups function return values into a tuple"""
+    if isinstance(return_ty, TupleType | NoneType) and not return_ty.preserve:
+        types = type_to_row(return_ty)
+        assert len(returns) == len(types)
+        hugr_tys = [t.to_hugr(ctx) for t in types]
+        return builder.add_op(ops.MakeTuple(hugr_tys), *returns)
+    assert (
+        len(returns) == 1
+    ), f"Expected a single return value. Got {returns}. return type {return_ty}"
+    return returns[0]
+
+
+def unpack_wire(
+    wire: Wire, return_ty: Type, builder: DfBase[ops.DfParentOp], ctx: CompilerContext
+) -> list[Wire]:
+    """The inverse of `pack_returns`"""
+    if isinstance(return_ty, TupleType | NoneType) and not return_ty.preserve:
+        types = type_to_row(return_ty)
+        hugr_tys = [t.to_hugr(ctx) for t in types]
+        return list(builder.add_op(ops.UnpackTuple(hugr_tys), wire).outputs())
+    return [wire]
+
+
 def instantiation_needs_unpacking(func_ty: FunctionType, inst: Inst) -> bool:
     """Checks if instantiating a polymorphic makes it return a row."""
     if isinstance(func_ty.output, BoundTypeVar):

{guppylang_internals-0.26.0 → guppylang_internals-0.27.0}/src/guppylang_internals/compiler/modifier_compiler.py

@@ -8,7 +8,7 @@ from guppylang_internals.checker.modifier_checker import non_copyable_front_othe
 from guppylang_internals.compiler.cfg_compiler import compile_cfg
 from guppylang_internals.compiler.core import CompilerContext, DFContainer
 from guppylang_internals.compiler.expr_compiler import ExprCompiler
-from guppylang_internals.definition.function import add_unitarity_metadata
+from guppylang_internals.definition.metadata import add_metadata
 from guppylang_internals.nodes import CheckedModifiedBlock, PlaceNode
 from guppylang_internals.std._internal.compiler.array import (
     array_new,
@@ -57,7 +57,10 @@ def compile_modified_block(
     func_builder = dfg.builder.module_root_builder().define_function(
         str(modified_block), hugr_ty.input, hugr_ty.output
     )
-    add_unitarity_metadata(func_builder, modified_block.ty.unitary_flags)
+    add_metadata(
+        func_builder,
+        additional_metadata={"unitary": modified_block.ty.unitary_flags.value},
+    )
 
     # compile body
     cfg = compile_cfg(modified_block.cfg, func_builder, func_builder.inputs(), ctx)

{guppylang_internals-0.26.0 → guppylang_internals-0.27.0}/src/guppylang_internals/decorator.py

@@ -26,7 +26,7 @@ from guppylang_internals.definition.ty import OpaqueTypeDef, TypeDef
 from guppylang_internals.definition.wasm import RawWasmFunctionDef
 from guppylang_internals.dummy_decorator import _dummy_custom_decorator, sphinx_running
 from guppylang_internals.engine import DEF_STORE
-from guppylang_internals.error import GuppyError
+from guppylang_internals.error import GuppyError, pretty_errors
 from guppylang_internals.std._internal.checker import WasmCallChecker
 from guppylang_internals.std._internal.compiler.wasm import (
     WasmModuleCallCompiler,
@@ -207,6 +207,7 @@ def custom_type(
     return dec
 
 
+@pretty_errors
 def wasm_module(
     filename: str,
 ) -> Callable[[builtins.type[T]], GuppyDefinition]:
@@ -252,6 +253,7 @@ def ext_module_decorator(
     def fun(
         filename: str, module: str | None
     ) -> Callable[[builtins.type[T]], GuppyDefinition]:
+        @pretty_errors
         def dec(cls: builtins.type[T]) -> GuppyDefinition:
             # N.B. Only one module per file and vice-versa
             ext_module = type_def(

{guppylang_internals-0.26.0 → guppylang_internals-0.27.0}/src/guppylang_internals/definition/function.py

@@ -33,6 +33,7 @@ from guppylang_internals.definition.common import (
     ParsableDef,
     UnknownSourceError,
 )
+from guppylang_internals.definition.metadata import GuppyMetadata, add_metadata
 from guppylang_internals.definition.value import (
     CallableDef,
     CallReturnWires,
@@ -72,13 +73,22 @@ class RawFunctionDef(ParsableDef):
 
     unitary_flags: UnitaryFlags = field(default=UnitaryFlags.NoFlags, kw_only=True)
 
+    metadata: GuppyMetadata | None = field(default=None, kw_only=True)
+
     def parse(self, globals: Globals, sources: SourceMap) -> "ParsedFunctionDef":
         """Parses and checks the user-provided signature of the function."""
         func_ast, docstring = parse_py_func(self.python_func, sources)
         ty = check_signature(
             func_ast, globals, self.id, unitary_flags=self.unitary_flags
         )
-        return ParsedFunctionDef(self.id, self.name, func_ast, ty, docstring)
+        return ParsedFunctionDef(
+            self.id,
+            self.name,
+            func_ast,
+            ty,
+            docstring,
+            metadata=self.metadata,
+        )
 
 
 @dataclass(frozen=True)
@@ -103,6 +113,8 @@ class ParsedFunctionDef(CheckableDef, CallableDef):
 
     description: str = field(default="function", init=False)
 
+    metadata: GuppyMetadata | None = field(default=None, kw_only=True)
+
     def check(self, globals: Globals) -> "CheckedFunctionDef":
         """Type checks the body of the function."""
         # Add python variable scope to the globals
@@ -114,6 +126,7 @@ class ParsedFunctionDef(CheckableDef, CallableDef):
             self.ty,
             self.docstring,
             cfg,
+            metadata=self.metadata,
         )
 
     def check_call(
@@ -177,7 +190,11 @@ class CheckedFunctionDef(ParsedFunctionDef, MonomorphizableDef):
         func_def = module.module_root_builder().define_function(
             self.name, hugr_ty.body.input, hugr_ty.body.output, hugr_ty.params
         )
-        add_unitarity_metadata(func_def, self.ty.unitary_flags)
+        add_metadata(
+            func_def,
+            self.metadata,
+            additional_metadata={"unitary": self.ty.unitary_flags.value},
+        )
         return CompiledFunctionDef(
             self.id,
             self.name,
@@ -187,6 +204,7 @@ class CheckedFunctionDef(ParsedFunctionDef, MonomorphizableDef):
             self.docstring,
             self.cfg,
             func_def,
+            metadata=self.metadata,
         )
 
 
@@ -305,8 +323,3 @@ def parse_source(source_lines: list[str], line_offset: int) -> tuple[str, ast.AS
     else:
         node = ast.parse(source).body[0]
     return source, node, line_offset
-
-
-def add_unitarity_metadata(func: hf.Function, flags: UnitaryFlags) -> None:
-    """Stores unitarity annotations in the metadate of a Hugr function definition."""
-    func.metadata["unitary"] = flags.value

guppylang_internals-0.27.0/src/guppylang_internals/definition/metadata.py

@@ -0,0 +1,87 @@
+"""Metadata attached to objects within the Guppy compiler, both for internal use and to
+attach to HUGR nodes for lower-level processing."""
+
+from abc import ABC
+from dataclasses import dataclass, field, fields
+from typing import Any, ClassVar, Generic, TypeVar
+
+from hugr.hugr.node_port import ToNode
+
+from guppylang_internals.diagnostic import Fatal
+from guppylang_internals.error import GuppyError
+
+T = TypeVar("T")
+
+
+@dataclass(init=True, kw_only=True)
+class GuppyMetadataValue(ABC, Generic[T]):
+    """A template class for a metadata value within the scope of the Guppy compiler.
+    Implementations should provide the `key` in reverse-URL format."""
+
+    key: ClassVar[str]
+    value: T | None = None
+
+
+class MetadataMaxQubits(GuppyMetadataValue[int]):
+    key = "tket.hint.max_qubits"
+
+
+@dataclass(frozen=True, init=True, kw_only=True)
+class GuppyMetadata:
+    """DTO for metadata within the scope of the guppy compiler for attachment to HUGR
+    nodes. See `add_metadata`."""
+
+    max_qubits: MetadataMaxQubits = field(default_factory=MetadataMaxQubits, init=False)
+
+    @classmethod
+    def reserved_keys(cls) -> set[str]:
+        return {f.type.key for f in fields(GuppyMetadata)}
+
+
+@dataclass(frozen=True)
+class MetadataAlreadySetError(Fatal):
+    title: ClassVar[str] = "Metadata key already set"
+    message: ClassVar[str] = "Received two values for the metadata key `{key}`"
+    key: str
+
+
+@dataclass(frozen=True)
+class ReservedMetadataKeysError(Fatal):
+    title: ClassVar[str] = "Metadata key is reserved"
+    message: ClassVar[str] = (
+        "The following metadata keys are reserved by Guppy but also provided in "
+        "additional metadata: `{keys}`"
+    )
+    keys: set[str]
+
+
+def add_metadata(
+    node: ToNode,
+    metadata: GuppyMetadata | None = None,
+    *,
+    additional_metadata: dict[str, Any] | None = None,
+) -> None:
+    """Adds metadata to the given node using the keys defined through inheritors of
+    `GuppyMetadataValue` defined in the `GuppyMetadata` class.
+
+    Additional metadata is forwarded as is, although the given dictionary may not
+    contain any keys already reserved by fields in `GuppyMetadata`.
+    """
+    if metadata is not None:
+        for f in fields(GuppyMetadata):
+            data: GuppyMetadataValue[Any] = getattr(metadata, f.name)
+            if data.key in node.metadata:
+                raise GuppyError(MetadataAlreadySetError(None, data.key))
+            if data.value is not None:
+                node.metadata[data.key] = data.value
+
+    if additional_metadata is not None:
+        reserved_keys = GuppyMetadata.reserved_keys()
+        used_reserved_keys = reserved_keys.intersection(additional_metadata.keys())
+        if len(used_reserved_keys) > 0:
+            raise GuppyError(ReservedMetadataKeysError(None, keys=used_reserved_keys))
+
+        for key, value in additional_metadata.items():
+            if key in node.metadata:
+                raise GuppyError(MetadataAlreadySetError(None, key))
+            node.metadata[key] = value

{guppylang_internals-0.26.0 → guppylang_internals-0.27.0}/src/guppylang_internals/definition/overloaded.py

@@ -1,4 +1,5 @@
 import ast
+import copy
 from contextlib import suppress
 from dataclasses import dataclass, field
 from typing import ClassVar, NoReturn
@@ -86,7 +87,11 @@ class OverloadedFunctionDef(CompiledCallableDef, CallableDef):
             assert isinstance(defn, CallableDef)
             available_sigs.append(defn.ty)
             with suppress(GuppyError):
-                return defn.check_call(args, ty, node, ctx)
+                # check_call may modify args and node,
+                # thus we deepcopy them before passing in the function
+                node_copy = copy.deepcopy(node)
+                args_copy = copy.deepcopy(args)
+                return defn.check_call(args_copy, ty, node_copy, ctx)
         return self._call_error(args, node, ctx, available_sigs, ty)
 
     def synthesize_call(
@@ -98,7 +103,11 @@ class OverloadedFunctionDef(CompiledCallableDef, CallableDef):
             assert isinstance(defn, CallableDef)
             available_sigs.append(defn.ty)
             with suppress(GuppyError):
-                return defn.synthesize_call(args, node, ctx)
+                # synthesize_call may modify args and node,
+                # thus we deepcopy them before passing in the function
+                node_copy = copy.deepcopy(node)
+                args_copy = copy.deepcopy(args)
+                return defn.synthesize_call(args_copy, node_copy, ctx)
         return self._call_error(args, node, ctx, available_sigs)
 
     def _call_error(

{guppylang_internals-0.26.0 → guppylang_internals-0.27.0}/src/guppylang_internals/definition/pytket_circuits.py

@@ -46,6 +46,7 @@ from guppylang_internals.std._internal.compiler.array import (
     array_new,
     array_unpack,
 )
+from guppylang_internals.std._internal.compiler.quantum import from_halfturns_unchecked
 from guppylang_internals.std._internal.compiler.tket_bool import OpaqueBool, make_opaque
 from guppylang_internals.tys.builtin import array_type, bool_type, float_type
 from guppylang_internals.tys.subst import Inst, Subst
@@ -235,12 +236,15 @@ class ParsedPytketDef(CallableDef, CompilableDef):
                     lex_names = sorted(param_order)
                     name_to_param = dict(zip(lex_names, lex_params, strict=True))
                     angle_wires = [name_to_param[name] for name in param_order]
-                    # Need to convert all angles to floats.
+                    # Need to convert all angles to rotations.
                     for angle in angle_wires:
                         [halfturns] = outer_func.add_op(
                             ops.UnpackTuple([FLOAT_T]), angle
                         )
-                        param_wires.append(halfturns)
+                        rotation = outer_func.add_op(
+                            from_halfturns_unchecked(), halfturns
+                        )
+                        param_wires.append(rotation)
 
                 # Pass all arguments to call node.
                 call_node = outer_func.call(

{guppylang_internals-0.26.0 → guppylang_internals-0.27.0}/src/guppylang_internals/diagnostic.py

@@ -208,7 +208,8 @@ class DiagnosticsRenderer:
     MAX_MESSAGE_LINE_LEN: Final[int] = 80
 
     #: Number of preceding source lines we show to give additional context
-    PREFIX_CONTEXT_LINES: Final[int] = 2
+    PREFIX_ERROR_CONTEXT_LINES: Final[int] = 2
+    PREFIX_NOTE_CONTEXT_LINES: Final[int] = 1
 
     def __init__(self, source: SourceMap) -> None:
         self.buffer = []
@@ -243,31 +244,84 @@ class DiagnosticsRenderer:
         else:
             span = to_span(diag.span)
             level = self.level_str(diag.level)
-            all_spans = [span] + [
-                to_span(child.span) for child in diag.children if child.span
+
+            children_with_span = [
+                (child, to_span(child.span)) for child in diag.children if child.span
             ]
+            all_spans = [span] + [span for _, span in children_with_span]
             max_lineno = max(s.end.line for s in all_spans)
+
             self.buffer.append(f"{level}: {diag.rendered_title} (at {span.start})")
+
+            # Render main error span first
             self.render_snippet(
                 span,
                 diag.rendered_span_label,
                 max_lineno,
                 is_primary=True,
-                prefix_lines=self.PREFIX_CONTEXT_LINES,
+                prefix_lines=self.PREFIX_ERROR_CONTEXT_LINES,
             )
-            # First render all sub-diagnostics that come with a span
-            for sub_diag in diag.children:
-                if sub_diag.span:
+
+            match children_with_span:
+                case []:
+                    pass
+                case [(only_child, span)]:
+                    self.buffer.append("\nNote:")
                     self.render_snippet(
-                        to_span(sub_diag.span),
-                        sub_diag.rendered_span_label,
+                        span,
+                        only_child.rendered_span_label,
                         max_lineno,
-                        is_primary=False,
+                        prefix_lines=self.PREFIX_NOTE_CONTEXT_LINES,
+                        print_pad_line=True,
                     )
+                case [(first_child, first_span), *children_with_span]:
+                    self.buffer.append("\nNotes:")
+                    self.render_snippet(
+                        first_span,
+                        first_child.rendered_span_label,
+                        max_lineno,
+                        prefix_lines=self.PREFIX_NOTE_CONTEXT_LINES,
+                        print_pad_line=True,
+                    )
+
+                    prev_span_end_lineno = first_span.end.line
+
+                    for sub_diag, span in children_with_span:
+                        span_start_lineno = span.start.line
+                        span_end_lineno = span.end.line
+
+                        # If notes are on the same line, render them together
+                        if span_start_lineno == prev_span_end_lineno:
+                            prefix_lines = 0
+                            print_pad_line = True
+                        # if notes are close enough, render them adjacently
+                        elif (
+                            span_start_lineno - self.PREFIX_NOTE_CONTEXT_LINES
+                            <= prev_span_end_lineno + 1
+                        ):
+                            prefix_lines = span_start_lineno - prev_span_end_lineno - 1
+                            print_pad_line = False
+                        # otherwise we render a separator between notes
+                        else:
+                            self.buffer.append("")
+                            prefix_lines = self.PREFIX_NOTE_CONTEXT_LINES
+                            print_pad_line = False
+
+                        self.render_snippet(
+                            span,
+                            sub_diag.rendered_span_label,
+                            max_lineno,
+                            prefix_lines=prefix_lines,
+                            print_pad_line=print_pad_line,
+                        )
+                        prev_span_end_lineno = span_end_lineno
+
+            # Render the main diagnostic message if present
             if diag.rendered_message:
                 self.buffer.append("")
                 self.buffer += wrap(diag.rendered_message, self.MAX_MESSAGE_LINE_LEN)
-        # Finally, render all sub-diagnostics that have a non-span message
+
+        # Render all sub-diagnostics that have a non-span message
         for sub_diag in diag.children:
             if sub_diag.rendered_message:
                 self.buffer.append("")
@@ -281,8 +335,9 @@ class DiagnosticsRenderer:
         span: Span,
         label: str | None,
         max_lineno: int,
-        is_primary: bool,
+        is_primary: bool = False,
         prefix_lines: int = 0,
+        print_pad_line: bool = False,
     ) -> None:
         """Renders the source associated with a span together with an optional label.
 
@@ -315,7 +370,8 @@ class DiagnosticsRenderer:
         Optionally includes up to `prefix_lines` preceding source lines to give
         additional context.
         """
-        # Check how much space we need to reserve for the leading line numbers
+        # Check how much horizontal space we need to reserve for the leading
+        # line numbers
         ll_length = len(str(max_lineno))
         highlight_char = "^" if is_primary else "-"
 
@@ -324,8 +380,9 @@ class DiagnosticsRenderer:
             ll = "" if line_number is None else str(line_number)
             self.buffer.append(" " * (ll_length - len(ll)) + ll + " | " + line)
 
-        # One line of padding
-        render_line("")
+        # One line of padding (primary span, first note or between same line notes)
+        if is_primary or print_pad_line:
+            render_line("")
 
         # Grab all lines we want to display and remove excessive leading whitespace
         prefix_lines = min(prefix_lines, span.start.line - 1)

{guppylang_internals-0.26.0 → guppylang_internals-0.27.0}/src/guppylang_internals/engine.py

@@ -220,21 +220,12 @@ class CompilationEngine:
 
         This is the main driver behind `guppy.check()`.
         """
-        from guppylang_internals.checker.core import Globals
-
         # Clear previous compilation cache.
         # TODO: In order to maintain results from the previous `check` call we would
         #  need to store and check if any dependencies have changed.
         self.reset()
 
-        defn = DEF_STORE.raw_defs[id]
-        self.to_check_worklist = {
-            defn.id: (
-                defn.parse(Globals(DEF_STORE.frames[defn.id]), DEF_STORE.sources)
-                if isinstance(defn, ParsableDef)
-                else defn
-            )
-        }
+        self.to_check_worklist[id] = self.get_parsed(id)
         while self.types_to_check_worklist or self.to_check_worklist:
             # Types need to be checked first. This is because parsing e.g. a function
             # definition requires instantiating the types in its signature which can