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

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

@@ -3,6 +3,58 @@
 First release of `guppylang_internals` package containing refactored out internal components
 from `guppylang`.
 
+## [0.28.0](https://github.com/Quantinuum/guppylang/compare/guppylang-internals-v0.27.0...guppylang-internals-v0.28.0) (2026-02-04)
+
+
+### ⚠ BREAKING CHANGES
+
+* Tket is now a non-optional dependency. Most systems already have this installed, rerunning the package manager should fix any issues.
+
+### Features
+
+* Label `FuncDefn`s with qualified names in HUGR ([#1452](https://github.com/Quantinuum/guppylang/issues/1452)) ([a92f274](https://github.com/Quantinuum/guppylang/commit/a92f274a14668b7ac88713a69a6902aca62d4483))
+* Make tket a non-optional dependency ([#1440](https://github.com/Quantinuum/guppylang/issues/1440)) ([4af4360](https://github.com/Quantinuum/guppylang/commit/4af4360495c9d6155e69310d5bfb8f22953fc1ff))
+* use hugr used_extensions in engine.py ([#1451](https://github.com/Quantinuum/guppylang/issues/1451)) ([c16b96b](https://github.com/Quantinuum/guppylang/commit/c16b96bd5dc6ab4df13e3242ffe55279b317dd7e))
+
+
+### Bug Fixes
+
+* Add a copy before fallable `synthesize_call` call  ([#1460](https://github.com/Quantinuum/guppylang/issues/1460)) ([84137c3](https://github.com/Quantinuum/guppylang/commit/84137c39b7e8ca24142ffe73afcce6a1bcceffe2))
+* Raise type inference error when not all function argument types could be resolved. ([#1439](https://github.com/Quantinuum/guppylang/issues/1439)) ([4120d59](https://github.com/Quantinuum/guppylang/commit/4120d590917245258d69ceb07c763c7633c7c5f8)), closes [#1437](https://github.com/Quantinuum/guppylang/issues/1437)
+* Remove leading tab characters from diagnostics during rendering ([#1447](https://github.com/Quantinuum/guppylang/issues/1447)) ([a1cf792](https://github.com/Quantinuum/guppylang/commit/a1cf792deaf90e31721505ac17fd4911737e6c26)), closes [#1101](https://github.com/Quantinuum/guppylang/issues/1101)
+* Support comptime expressions in subscript assignments ([#1433](https://github.com/Quantinuum/guppylang/issues/1433)) ([108c104](https://github.com/Quantinuum/guppylang/commit/108c104d55ecb052d4d7c363062f444efc689724)), closes [#1363](https://github.com/Quantinuum/guppylang/issues/1363)
+* Support more cases of comptime subscripts ([#1436](https://github.com/Quantinuum/guppylang/issues/1436)) ([9aefdcc](https://github.com/Quantinuum/guppylang/commit/9aefdcc50b142acf842cf60314b5bccc49e01614)), closes [#1435](https://github.com/Quantinuum/guppylang/issues/1435)
+
+## [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.28.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guppylang-internals
-Version: 0.26.0
+Version: 0.28.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,12 +219,13 @@ 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.1
+Requires-Dist: pytket>=1.34
 Requires-Dist: tket-exts~=0.12.0
+Requires-Dist: tket>=0.12.7
 Requires-Dist: typing-extensions<5,>=4.9.0
-Requires-Dist: wasmtime~=v38.0.0
+Requires-Dist: wasmtime<41.1,>=38.0
 Provides-Extra: pytket
-Requires-Dist: pytket>=1.34; extra == 'pytket'
 Description-Content-Type: text/markdown
 
 # guppylang-internals

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

@@ -1,6 +1,6 @@
 [project]
 name = "guppylang-internals"
-version = "0.26.0"
+version = "0.28.0"
 requires-python = ">=3.10,<4"
 description = "Compiler internals for `guppylang` package."
 license = { file = "LICENCE" }
@@ -16,13 +16,10 @@ maintainers = [
 
 classifiers = [
     "Development Status :: 3 - Alpha",
-
     "Intended Audience :: Developers",
     "Intended Audience :: Science/Research",
     "Topic :: Software Development :: Compilers",
-
     "License :: OSI Approved :: Apache Software License",
-
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
@@ -35,12 +32,14 @@ classifiers = [
 dependencies = [
     "typing-extensions >=4.9.0,<5",
     "tket-exts ~= 0.12.0",
-    "hugr ~= 0.14.1",
-    "wasmtime ~= v38.0.0",
+    "hugr ~= 0.15.1",
+    "wasmtime>=38.0,<41.1",
+    "pytket>=1.34",
+    "tket >= 0.12.7",
 ]
 
 [project.optional-dependencies]
-pytket = ["pytket>=1.34"]
+pytket = []
 
 [build-system]
 requires = ["hatchling"]

{guppylang_internals-0.26.0 → guppylang_internals-0.28.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.28.0"

{guppylang_internals-0.26.0 → guppylang_internals-0.28.0}/src/guppylang_internals/ast_util.py

@@ -97,13 +97,13 @@ def find_nodes(
 def name_nodes_in_ast(node: Any) -> list[ast.Name]:
     """Returns all `Name` nodes occurring in an AST."""
     found = find_nodes(lambda n: isinstance(n, ast.Name), node)
-    return cast(list[ast.Name], found)
+    return cast("list[ast.Name]", found)
 
 
 def return_nodes_in_ast(node: Any) -> list[ast.Return]:
     """Returns all `Return` nodes occurring in an AST."""
     found = find_nodes(lambda n: isinstance(n, ast.Return), node, {ast.FunctionDef})
-    return cast(list[ast.Return], found)
+    return cast("list[ast.Return]", found)
 
 
 def loop_in_ast(node: Any) -> list[ast.For | ast.While]:
@@ -111,7 +111,7 @@ def loop_in_ast(node: Any) -> list[ast.For | ast.While]:
     found = find_nodes(
         lambda n: isinstance(n, ast.For | ast.While), node, {ast.FunctionDef}
     )
-    return cast(list[ast.For | ast.While], found)
+    return cast("list[ast.For | ast.While]", found)
 
 
 def breaks_in_loop(node: Any) -> list[ast.Break]:
@@ -122,7 +122,7 @@ def breaks_in_loop(node: Any) -> list[ast.Break]:
     found = find_nodes(
         lambda n: isinstance(n, ast.Break), node, {ast.For, ast.While, ast.FunctionDef}
     )
-    return cast(list[ast.Break], found)
+    return cast("list[ast.Break]", found)
 
 
 def loop_controls_in_loop(node: Any) -> list[ast.Break | ast.Continue]:
@@ -135,7 +135,7 @@ def loop_controls_in_loop(node: Any) -> list[ast.Break | ast.Continue]:
         node,
         {ast.For, ast.While, ast.FunctionDef},
     )
-    return cast(list[ast.Break | ast.Continue], found)
+    return cast("list[ast.Break | ast.Continue]", found)
 
 
 class ContextAdjuster(ast.NodeTransformer):
@@ -147,7 +147,7 @@ class ContextAdjuster(ast.NodeTransformer):
         self.ctx = ctx
 
     def visit(self, node: ast.AST) -> ast.AST:
-        return cast(ast.AST, super().visit(node))
+        return cast("ast.AST", super().visit(node))
 
     def visit_Name(self, node: ast.Name) -> ast.Name:
         return with_loc(node, ast.Name(id=node.id, ctx=self.ctx))
@@ -156,29 +156,48 @@ class ContextAdjuster(ast.NodeTransformer):
         self,
         node: ast.Starred,
     ) -> ast.Starred:
-        return with_loc(node, ast.Starred(value=self.visit(node.value), ctx=self.ctx))
+        return with_loc(
+            node,
+            ast.Starred(value=self.visit(node.value), ctx=self.ctx),  # type: ignore[arg-type]
+        )
 
     def visit_Tuple(self, node: ast.Tuple) -> ast.Tuple:
         return with_loc(
-            node, ast.Tuple(elts=[self.visit(elt) for elt in node.elts], ctx=self.ctx)
+            node,
+            ast.Tuple(
+                elts=[self.visit(elt) for elt in node.elts],  # type: ignore[misc]
+                ctx=self.ctx,
+            ),
         )
 
     def visit_List(self, node: ast.List) -> ast.List:
         return with_loc(
-            node, ast.List(elts=[self.visit(elt) for elt in node.elts], ctx=self.ctx)
+            node,
+            ast.List(
+                elts=[self.visit(elt) for elt in node.elts],  # type: ignore[misc]
+                ctx=self.ctx,
+            ),
         )
 
     def visit_Subscript(self, node: ast.Subscript) -> ast.Subscript:
         # Don't adjust the slice!
         return with_loc(
             node,
-            ast.Subscript(value=self.visit(node.value), slice=node.slice, ctx=self.ctx),
+            ast.Subscript(
+                value=self.visit(node.value),  # type: ignore[arg-type]
+                slice=node.slice,
+                ctx=self.ctx,
+            ),
         )
 
     def visit_Attribute(self, node: ast.Attribute) -> ast.Attribute:
         return with_loc(
             node,
-            ast.Attribute(value=self.visit(node.value), attr=node.attr, ctx=self.ctx),
+            ast.Attribute(
+                value=self.visit(node.value),  # type: ignore[arg-type]
+                attr=node.attr,
+                ctx=self.ctx,
+            ),
         )
 
 
@@ -240,15 +259,15 @@ def template_replace(
 
 def line_col(node: ast.AST) -> tuple[int, int]:
     """Returns the line and column of an ast node."""
-    return node.lineno, node.col_offset
+    return node.lineno, node.col_offset  # type: ignore[attr-defined]
 
 
 def set_location_from(node: ast.AST, loc: ast.AST) -> None:
     """Copy source location from one AST node to the other."""
-    node.lineno = loc.lineno
-    node.col_offset = loc.col_offset
-    node.end_lineno = loc.end_lineno
-    node.end_col_offset = loc.end_col_offset
+    node.lineno = loc.lineno  # type: ignore[attr-defined]
+    node.col_offset = loc.col_offset  # type: ignore[attr-defined]
+    node.end_lineno = loc.end_lineno  # type: ignore[attr-defined]
+    node.end_col_offset = loc.end_col_offset  # type: ignore[attr-defined]
 
     source, file, line_offset = get_source(loc), get_file(loc), get_line_offset(loc)
     assert source is not None
@@ -341,11 +360,11 @@ def with_type(ty: "Type", node: A) -> A:
 
 def get_type_opt(node: AstNode) -> Optional["Type"]:
     """Tries to retrieve a type annotation from an AST node."""
-    from guppylang_internals.tys.ty import Type, TypeBase
+    from guppylang_internals.tys.ty import TypeBase
 
     try:
         ty = node.type  # type: ignore[union-attr]
-        return cast(Type, ty) if isinstance(ty, TypeBase) else None
+        return cast("Type", ty) if isinstance(ty, TypeBase) else None
     except AttributeError:
         return None
 

{guppylang_internals-0.26.0 → guppylang_internals-0.28.0}/src/guppylang_internals/cfg/analysis.py

@@ -11,7 +11,7 @@ T = TypeVar("T")
 Result = dict[BB, T]
 
 
-class Analysis(Generic[T], ABC):
+class Analysis(ABC, Generic[T]):
     """Abstract base class for a program analysis pass over the lattice `T`"""
 
     def eq(self, t1: T, t2: T, /) -> bool:
@@ -39,7 +39,7 @@ class Analysis(Generic[T], ABC):
         """
 
 
-class ForwardAnalysis(Generic[T], Analysis[T], ABC):
+class ForwardAnalysis(Analysis[T], ABC, Generic[T]):
     """Abstract base class for a program analysis pass running in forward direction."""
 
     @abstractmethod
@@ -71,7 +71,7 @@ class ForwardAnalysis(Generic[T], Analysis[T], ABC):
         return vals_before
 
 
-class BackwardAnalysis(Generic[T], Analysis[T], ABC):
+class BackwardAnalysis(Analysis[T], ABC, Generic[T]):
     """Abstract base class for a program analysis pass running in backward direction."""
 
     @abstractmethod
@@ -105,7 +105,7 @@ class BackwardAnalysis(Generic[T], Analysis[T], ABC):
 LivenessDomain = dict[VId, BB]
 
 
-class LivenessAnalysis(Generic[VId], BackwardAnalysis[LivenessDomain[VId]]):
+class LivenessAnalysis(BackwardAnalysis[LivenessDomain[VId]], Generic[VId]):
     """Live variable analysis pass.
 
     Computes the variables that are live before the execution of each BB. The analysis
@@ -143,7 +143,7 @@ class LivenessAnalysis(Generic[VId], BackwardAnalysis[LivenessDomain[VId]]):
 
     def apply_bb(self, live_after: LivenessDomain[VId], bb: BB) -> LivenessDomain[VId]:
         stats = self.stats[bb]
-        return {x: bb for x in stats.used} | {
+        return dict.fromkeys(stats.used, bb) | {
             x: b for x, b in live_after.items() if x not in stats.assigned
         }
 
@@ -159,7 +159,7 @@ MaybeAssignmentDomain = set[VId]
 AssignmentDomain = tuple[DefAssignmentDomain[VId], MaybeAssignmentDomain[VId]]
 
 
-class AssignmentAnalysis(Generic[VId], ForwardAnalysis[AssignmentDomain[VId]]):
+class AssignmentAnalysis(ForwardAnalysis[AssignmentDomain[VId]], Generic[VId]):
     """Assigned variable analysis pass.
 
     Computes the set of variables (i.e. `V`s) that are definitely assigned at the start

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

@@ -154,27 +154,52 @@ class CFGBuilder(AstVisitor[BB | None]):
         return bb_opt
 
     def _build_node_value(self, node: BBStatement, bb: BB) -> BB:
-        """Utility method for building a node containing a `value` expression.
+        """Utility method for building a nodes `value` expression, if available.
 
         Builds the expression and mutates `node.value` to point to the built expression.
-        Returns the BB in which the expression is available and adds the node to it.
+        Returns the BB in which the expression is available.
         """
         if (
             not isinstance(node, NestedFunctionDef | ModifiedBlock)
             and node.value is not None
         ):
             node.value, bb = ExprBuilder.build(node.value, self.cfg, bb)
-        bb.statements.append(node)
+        return bb
+
+    def _build_node_targets(self, node: BBStatement, bb: BB) -> BB:
+        """Utility method for building a nodes `target` or `targets` expressions,
+        depending on the node type.
+
+        Builds the expressions and mutates the elements of `node.targets` to point to
+        the built expressions. Returns the BB in which the expressions are available.
+        """
+        if isinstance(node, ast.Assign):
+            for i, target in enumerate(node.targets):
+                node.targets[i], bb = ExprBuilder.build(target, self.cfg, bb)
+        elif isinstance(node, ast.AugAssign | ast.AnnAssign):
+            new_target, bb = ExprBuilder.build(node.target, self.cfg, bb)
+            if not isinstance(new_target, ast.Name | ast.Attribute | ast.Subscript):
+                raise InternalGuppyError("Unexpected type for built expression.")
+            node.target = new_target
         return bb
 
     def visit_Assign(self, node: ast.Assign, bb: BB, jumps: Jumps) -> BB | None:
-        return self._build_node_value(node, bb)
+        bb = self._build_node_value(node, bb)
+        bb = self._build_node_targets(node, bb)
+        bb.statements.append(node)
+        return bb
 
     def visit_AugAssign(self, node: ast.AugAssign, bb: BB, jumps: Jumps) -> BB | None:
-        return self._build_node_value(node, bb)
+        bb = self._build_node_value(node, bb)
+        bb = self._build_node_targets(node, bb)
+        bb.statements.append(node)
+        return bb
 
     def visit_AnnAssign(self, node: ast.AnnAssign, bb: BB, jumps: Jumps) -> BB | None:
-        return self._build_node_value(node, bb)
+        bb = self._build_node_value(node, bb)
+        bb = self._build_node_targets(node, bb)
+        bb.statements.append(node)
+        return bb
 
     def visit_Expr(self, node: ast.Expr, bb: BB, jumps: Jumps) -> BB | None:
         # This is an expression statement where the value is discarded
@@ -262,6 +287,7 @@ class CFGBuilder(AstVisitor[BB | None]):
 
     def visit_Return(self, node: ast.Return, bb: BB, jumps: Jumps) -> BB | None:
         bb = self._build_node_value(node, bb)
+        bb.statements.append(node)
         self.cfg.link(bb, jumps.return_bb)
         return None
 
@@ -572,7 +598,7 @@ class BranchBuilder(AstVisitor[None]):
                     comparators[:-1], node.ops, comparators[1:], strict=True
                 )
             ]
-            conj = ast.BoolOp(op=ast.And(), values=values)
+            conj = ast.BoolOp(op=ast.And(), values=values)  # type: ignore[arg-type]
             set_location_from(conj, node)
             self.visit_BoolOp(conj, bb, true_bb, false_bb)
         else:
@@ -668,6 +694,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)
@@ -679,8 +708,8 @@ def is_comptime_expression(node: ast.AST) -> ComptimeExpr | None:
             case [arg]:
                 pass
             case args:
-                arg = with_loc(node, ast.Tuple(elts=args, ctx=ast.Load))
-        return with_loc(node, ComptimeExpr(value=arg))
+                arg = with_loc(node, ast.Tuple(elts=args, ctx=ast.Load))  # type: ignore[arg-type]
+        return with_loc(node, ComptimeExpr(arg))
     return None
 
 
@@ -701,7 +730,7 @@ def is_illegal_in_list_comp(node: ast.AST) -> bool:
 
 def make_var(name: str, loc: ast.AST | None = None) -> ast.Name:
     """Creates an `ast.Name` node."""
-    node = ast.Name(id=name, ctx=ast.Load)
+    node = ast.Name(id=name, ctx=ast.Load)  # type: ignore[arg-type]
     if loc is not None:
         set_location_from(node, loc)
     return node
@@ -715,5 +744,8 @@ def make_assign(lhs: list[ast.AST], value: ast.expr) -> ast.Assign:
     if len(lhs) == 1:
         target = lhs[0]
     else:
-        target = with_loc(value, ast.Tuple(elts=lhs, ctx=ast.Store()))
-    return with_loc(value, ast.Assign(targets=[target], value=value))
+        target = with_loc(
+            value,
+            ast.Tuple(elts=lhs, ctx=ast.Store()),  # type: ignore[arg-type]
+        )
+    return with_loc(value, ast.Assign(targets=[target], value=value))  # type: ignore[list-item]

{guppylang_internals-0.26.0 → guppylang_internals-0.28.0}/src/guppylang_internals/cfg/cfg.py

@@ -118,7 +118,7 @@ class CFG(BaseCFG[BB]):
         # initial value in the liveness analysis. This solves the edge case that
         # borrowed variables should be considered live, even if the exit is actually
         # unreachable (to avoid linearity violations later).
-        inout_live = {x: self.exit_bb for x in inout_vars}
+        inout_live = dict.fromkeys(inout_vars, self.exit_bb)
         self.live_before = LivenessAnalysis(
             stats, initial=inout_live, include_unreachable=True
         ).run(self.bbs)

{guppylang_internals-0.26.0 → guppylang_internals-0.28.0}/src/guppylang_internals/checker/core.py

@@ -384,7 +384,7 @@ class Globals:
             case _:
                 return assert_never(ty)
 
-        type_defn = cast(TypeDef, ENGINE.get_checked(type_defn.id))
+        type_defn = cast("TypeDef", ENGINE.get_checked(type_defn.id))
         if type_defn.id in DEF_STORE.impls and name in DEF_STORE.impls[type_defn.id]:
             def_id = DEF_STORE.impls[type_defn.id][name]
             defn = ENGINE.get_parsed(def_id)

{guppylang_internals-0.26.0 → guppylang_internals-0.28.0}/src/guppylang_internals/checker/errors/comptime_errors.py

@@ -44,18 +44,6 @@ class ComptimeExprIncoherentListError(Error):
     span_label: ClassVar[str] = "List contains elements with different types"
 
 
-@dataclass(frozen=True)
-class TketNotInstalled(Error):
-    title: ClassVar[str] = "Tket not installed"
-    span_label: ClassVar[str] = (
-        "Experimental pytket compatibility requires `tket` to be installed"
-    )
-
-    @dataclass(frozen=True)
-    class InstallInstruction(Help):
-        message: ClassVar[str] = "Install tket: `pip install tket`"
-
-
 @dataclass(frozen=True)
 class PytketSignatureMismatch(Error):
     title: ClassVar[str] = "Signature mismatch"

{guppylang_internals-0.26.0 → guppylang_internals-0.28.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