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

guppylang_internals-0.26.0/CHANGELOG.md

@@ -0,0 +1,161 @@
+# Changelog
+
+First release of `guppylang_internals` package containing refactored out internal components
+from `guppylang`.
+
+## [0.26.0](https://github.com/Quantinuum/guppylang/compare/guppylang-internals-v0.25.0...guppylang-internals-v0.26.0) (2025-12-11)
+
+
+### ⚠ BREAKING CHANGES
+
+* `FunctionType` constructor no longer accepts the `input_names` argument. Instead, input names should be provided as an optional argument to `FuncInput`
+* Removed `guppylang_internals.nodes.ResultExpr` Moved `guppylang_internals.std._internal.checker.{TAG_MAX_LEN, TooLongError}` to `guppylang_internals.std._internal.compiler.platform`
+* 
+* The `tag` field of `guppylang_internals.nodes.{ResultExpr, StateResultExpr}` has been replaced with a const `tag_value` and a `tag_expr` expression
+* `guppylang_internals.tys.ty.SumType` has been removed
+* 
+* `modifier_checker.check_modified_block_signature` now requires the `ModifiedBlock` as first argument
+
+### Features
+
+* Allow dynamic tag and signal in `panic`/`exit` ([#1327](https://github.com/Quantinuum/guppylang/issues/1327)) ([bae0da1](https://github.com/Quantinuum/guppylang/commit/bae0da1d42eea88d34c5c7bdd3d7f8a2504f1501))
+* Unitarity annotations for functions ([#1292](https://github.com/Quantinuum/guppylang/issues/1292)) ([54dc200](https://github.com/Quantinuum/guppylang/commit/54dc200de881d065d3ee92bdc9a8ca076990d412))
+* Validate signatures against wasm file ([#1339](https://github.com/Quantinuum/guppylang/issues/1339)) ([e57059b](https://github.com/Quantinuum/guppylang/commit/e57059b0ed61e6d76492e52d2a6f8c83f421e46b))
+
+
+### Bug Fixes
+
+* Allow comptime string arguments as result tags ([#1354](https://github.com/Quantinuum/guppylang/issues/1354)) ([cdc5c68](https://github.com/Quantinuum/guppylang/commit/cdc5c680879ae160bb592212cc8ed2fe6fc9ddbe))
+* Fix calls with comptime args inside comptime functions ([#1360](https://github.com/Quantinuum/guppylang/issues/1360)) ([8321303](https://github.com/Quantinuum/guppylang/commit/83213034a3c74e158bb58bbd1ff34ab7d253d981)), closes [#1359](https://github.com/Quantinuum/guppylang/issues/1359)
+* Fix internal compiler error when returning generic functions as values in comptime ([#1337](https://github.com/Quantinuum/guppylang/issues/1337)) ([8e2eba7](https://github.com/Quantinuum/guppylang/commit/8e2eba7e75e965405a903308b237344b83a3b168)), closes [#1335](https://github.com/Quantinuum/guppylang/issues/1335)
+* Handle subscript borrows involving index coercions ([#1358](https://github.com/Quantinuum/guppylang/issues/1358)) ([aee0dd8](https://github.com/Quantinuum/guppylang/commit/aee0dd8b34932b6badef6b9336a7f350e241815b)), closes [#1356](https://github.com/Quantinuum/guppylang/issues/1356)
+
+
+### Miscellaneous Chores
+
+* Remove `SumType` ([#1345](https://github.com/Quantinuum/guppylang/issues/1345)) ([b914dfe](https://github.com/Quantinuum/guppylang/commit/b914dfe374a6d7c2a4fe9f95d4f6e8f2ac0675e7))
+
+
+### Code Refactoring
+
+* Implement `result` using overloads instead of a custom node ([#1361](https://github.com/Quantinuum/guppylang/issues/1361)) ([1da2c5d](https://github.com/Quantinuum/guppylang/commit/1da2c5dbb82bf6da35949b505a69f4e2f51acd3b))
+* Store function argument names in `FuncInput` ([#1286](https://github.com/Quantinuum/guppylang/issues/1286)) ([b701840](https://github.com/Quantinuum/guppylang/commit/b70184098a65cde48c82da89ccbb4e50d1750f1d))
+
+## [0.25.0](https://github.com/quantinuum/guppylang/compare/guppylang-internals-v0.24.0...guppylang-internals-v0.25.0) (2025-10-28)
+
+
+### ⚠ BREAKING CHANGES
+
+* (guppy-internals) Arrays are now lowered to `borrow_array`s instead of `value_array`s so elements do no longer need to be wrapped in options during lowering.
+* `checker.core.requires_monomorphization` renamed into `require_monomorphization` and now operating on all parameters simultaneously `tys.subst.BoundVarFinder` removed. Instead, use the new `bound_vars` property on types, arguments, and consts. `tys.parsing.parse_parameter` now requires a `param_var_mapping`.
+
+### Features
+
+* compiler for modifiers ([#1287](https://github.com/quantinuum/guppylang/issues/1287)) ([439ff1a](https://github.com/quantinuum/guppylang/commit/439ff1ae6bd872bb7a6eb5441110d2febebd1e47))
+* modifiers in CFG and its type checker (experimental) ([#1281](https://github.com/quantinuum/guppylang/issues/1281)) ([fe85018](https://github.com/quantinuum/guppylang/commit/fe8501854507c3c43cec2f26bba75198766a4a17))
+* Turn type parameters into dependent telescopes ([#1154](https://github.com/quantinuum/guppylang/issues/1154)) ([b56e056](https://github.com/quantinuum/guppylang/commit/b56e056a6b4795c778ed8124a09a194fb1d97dda))
+* update hugr, tket-exts and tket ([#1305](https://github.com/quantinuum/guppylang/issues/1305)) ([6990d85](https://github.com/quantinuum/guppylang/commit/6990d850170e6901f60ef1d1e718c99349105b56))
+* Use `borrow_array` instead of `value_array` for array lowering ([#1166](https://github.com/quantinuum/guppylang/issues/1166)) ([f9ef42b](https://github.com/quantinuum/guppylang/commit/f9ef42b2baf61c3e1c2cfcf7bd1f3bcac33a1a25))
+
+
+### Bug Fixes
+
+* compilation of affine-bounded type variables ([#1308](https://github.com/quantinuum/guppylang/issues/1308)) ([49ecb49](https://github.com/quantinuum/guppylang/commit/49ecb497bf450d0853baec1de9c516a3804a80eb))
+* Detect unsolved generic parameters even if they are unused ([#1279](https://github.com/quantinuum/guppylang/issues/1279)) ([f830db0](https://github.com/quantinuum/guppylang/commit/f830db00c416cfc1e9fe7ec70c612b6b558aa740)), closes [#1273](https://github.com/quantinuum/guppylang/issues/1273)
+* Fix bug in symbolic pytket circuit loading with arrays ([#1302](https://github.com/quantinuum/guppylang/issues/1302)) ([e6b90e8](https://github.com/quantinuum/guppylang/commit/e6b90e8e4d275d36514a75e87eb097383495a291)), closes [#1298](https://github.com/quantinuum/guppylang/issues/1298)
+* Improve track_hugr_side_effects, adding Order edges from/to Input/Output ([#1311](https://github.com/quantinuum/guppylang/issues/1311)) ([3c6ce7a](https://github.com/quantinuum/guppylang/commit/3c6ce7aaf7a1c93c6412501976fc97afd61a062d))
+* multiline loop arguments  ([#1309](https://github.com/quantinuum/guppylang/issues/1309)) ([836ef72](https://github.com/quantinuum/guppylang/commit/836ef722d8f8bdb02c56e5f06934246a718e68d3))
+
+## [0.24.0](https://github.com/quantinuum/guppylang/compare/guppylang-internals-v0.23.0...guppylang-internals-v0.24.0) (2025-09-19)
+
+
+### ⚠ BREAKING CHANGES
+
+* `guppylang_internals.decorator.extend_type` now returns a `GuppyDefinition` by default. To get the previous behaviour of returning the annotated class unchanged, pass `return_class=True`.
+* `TypeDef`s now require a `params` field
+* guppylang_internals.ty.parsing.parse_function_io_types replaced with parse_function_arg_annotation and check_function_arg
+* Significant changes to the WASM decorators, types and operations
+* Deleted `guppylang_internals.nodes.{IterHasNext, IterEnd}`
+* guppylang_internals.tracing.unpacking.update_packed_value now returns a bool signalling whether the operation was successful.
+* `CompilationEngine` now initialises all it's fields
+* Calling `CompilationEngine.reset` no longer nullifies `additional_extensions`
+* `CompilationEngine.register_extension` no longer adds duplicates to the `additional_extensions` list
+
+### Features
+
+* Infer type of `self` arguments ([#1192](https://github.com/quantinuum/guppylang/issues/1192)) ([51f5a2b](https://github.com/quantinuum/guppylang/commit/51f5a2b3a9b06bc4ab054f32a4d07f7395df8ff4))
+
+
+### Bug Fixes
+
+* Add init to CompilationEngine; don't trash additional_extensions ([#1256](https://github.com/quantinuum/guppylang/issues/1256)) ([e413748](https://github.com/quantinuum/guppylang/commit/e413748532db3895cab4925a222177a4fa3fd61b))
+* Allow generic specialization of methods ([#1206](https://github.com/quantinuum/guppylang/issues/1206)) ([93936cc](https://github.com/quantinuum/guppylang/commit/93936cc275c56dd856d11fabc7aac20176304147)), closes [#1182](https://github.com/quantinuum/guppylang/issues/1182)
+* Correctly update borrowed values after calls and catch cases where it's impossible ([#1253](https://github.com/quantinuum/guppylang/issues/1253)) ([3ec5462](https://github.com/quantinuum/guppylang/commit/3ec54627729b49689da006a743e9e2c359cd3728))
+* Fix `nat` constructor in comptime functions ([#1258](https://github.com/quantinuum/guppylang/issues/1258)) ([e257b6f](https://github.com/quantinuum/guppylang/commit/e257b6fc2fe3793d6d8f63feca83bf5ed6643673))
+* Fix incorrect leak error for borrowing functions in comptime ([#1252](https://github.com/quantinuum/guppylang/issues/1252)) ([855244e](https://github.com/quantinuum/guppylang/commit/855244e2d5e3aeb04c2028f9f2310dba0e74210a)), closes [#1249](https://github.com/quantinuum/guppylang/issues/1249)
+* wasm module updates based on tested lowering ([#1230](https://github.com/quantinuum/guppylang/issues/1230)) ([657cea2](https://github.com/quantinuum/guppylang/commit/657cea27af00a9c02e8d1a3190db535bbd1e7981))
+
+
+### Miscellaneous Chores
+
+* Delete unused old iterator AST nodes ([#1215](https://github.com/quantinuum/guppylang/issues/1215)) ([2310897](https://github.com/quantinuum/guppylang/commit/231089750e33cf70754e5218feed64053c558c17))
+
+## [0.23.0](https://github.com/quantinuum/guppylang/compare/guppylang-internals-v0.22.0...guppylang-internals-v0.23.0) (2025-08-19)
+
+
+### ⚠ BREAKING CHANGES
+
+* `check_rows_match` no longer takes `globals` Deleted `GlobalShadowError` and `BranchTypeError.GlobalHint`
+
+### Bug Fixes
+
+* Fix globals vs locals scoping behaviour to match Python ([#1169](https://github.com/quantinuum/guppylang/issues/1169)) ([a6a91ca](https://github.com/quantinuum/guppylang/commit/a6a91ca32ad7c67bf1d733eb26c016a2662256ef))
+* Fix scoping issues with comprehensions in comptime expressions ([#1218](https://github.com/quantinuum/guppylang/issues/1218)) ([0b990e2](https://github.com/quantinuum/guppylang/commit/0b990e2b006c31352675004aec63a857f03a0793))
+
+
+### Documentation
+
+* use results sequence protocol for simplicity ([#1208](https://github.com/quantinuum/guppylang/issues/1208)) ([f9c1aee](https://github.com/quantinuum/guppylang/commit/f9c1aee38776c678660ede5495989ac4d75baaeb))
+
+## [0.22.0](https://github.com/quantinuum/guppylang/compare/guppylang-internals-v0.21.2...guppylang-internals-v0.22.0) (2025-08-11)
+
+
+### ⚠ BREAKING CHANGES
+
+* RangeChecker has been deleted.
+
+### Features
+
+* Add float parameter inputs to symbolic pytket circuits ([#1105](https://github.com/quantinuum/guppylang/issues/1105)) ([34c546c](https://github.com/quantinuum/guppylang/commit/34c546c3b5787beb839687fdbf4db8bc94f36c4a)), closes [#1076](https://github.com/quantinuum/guppylang/issues/1076)
+* Allow custom start and step in `range` ([#1157](https://github.com/quantinuum/guppylang/issues/1157)) ([a1b9333](https://github.com/quantinuum/guppylang/commit/a1b9333712c74270d5efaaa72f83d6b09047c068))
+* Improve codegen for array unpacking ([#1106](https://github.com/quantinuum/guppylang/issues/1106)) ([f375097](https://github.com/quantinuum/guppylang/commit/f3750973a719b03d27668a3ae39f58c8424deffc))
+* Insert drop ops for affine values ([#1090](https://github.com/quantinuum/guppylang/issues/1090)) ([083133e](https://github.com/quantinuum/guppylang/commit/083133e809873fce265bb78547fc3e519cb66ea1))
+
+
+### Bug Fixes
+
+* Fix builtins mock escaping the tracing scope ([#1161](https://github.com/quantinuum/guppylang/issues/1161)) ([a27a5c1](https://github.com/quantinuum/guppylang/commit/a27a5c19560d76e46678f846476ea86e873ac8ac))
+
+## [0.21.1](https://github.com/quantinuum/guppylang/compare/guppylang-internals-v0.21.0...guppylang-internals-v0.21.1) (2025-08-05)
+
+
+### Bug Fixes
+
+* **guppylang-internals:** Fix circular import for custom decorators ([#1146](https://github.com/quantinuum/guppylang/issues/1146)) ([d8474d8](https://github.com/quantinuum/guppylang/commit/d8474d8af3d394275268cd3d0754ff06ecb9bcc2)), closes [#1145](https://github.com/quantinuum/guppylang/issues/1145)
+* Support `None` value ([#1149](https://github.com/quantinuum/guppylang/issues/1149)) ([7f606c7](https://github.com/quantinuum/guppylang/commit/7f606c778d98312a0d1c4a9c7a27448c24d80585)), closes [#1148](https://github.com/quantinuum/guppylang/issues/1148)
+
+
+### Documentation
+
+* Fix docs build ([#1142](https://github.com/quantinuum/guppylang/issues/1142)) ([4dfd575](https://github.com/quantinuum/guppylang/commit/4dfd575bcdfdf1e2db4e61f2f406fff27e0c08f7))
+
+## [0.21.0](https://github.com/quantinuum/guppylang/compare/guppylang-internals-v0.20.0...guppylang-internals-v0.21.0) (2025-08-04)
+
+
+### ⚠ BREAKING CHANGES
+
+* All compiler-internal and non-userfacing functionality is moved into a new `guppylang_internals` package
+
+### Code Refactoring
+
+* Split up into `guppylang_internals` package ([#1126](https://github.com/quantinuum/guppylang/issues/1126)) ([81d50c0](https://github.com/quantinuum/guppylang/commit/81d50c0a24f55eca48d62e4b0275ef2126c5e626))

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guppylang-internals
-Version: 0.25.0
+Version: 0.26.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>
@@ -222,6 +222,7 @@ Requires-Python: <4,>=3.10
 Requires-Dist: hugr~=0.14.1
 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

{guppylang_internals-0.25.0 → guppylang_internals-0.26.0}/README.md

@@ -16,10 +16,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

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

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

{guppylang_internals-0.25.0 → guppylang_internals-0.26.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.25.0"
+__version__ = "0.26.0"

{guppylang_internals-0.25.0 → guppylang_internals-0.26.0}/src/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

{guppylang_internals-0.25.0 → guppylang_internals-0.26.0}/src/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-0.25.0 → guppylang_internals-0.26.0}/src/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-0.25.0 → guppylang_internals-0.26.0}/src/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-0.25.0 → guppylang_internals-0.26.0}/src/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-0.25.0 → guppylang_internals-0.26.0}/src/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,
@@ -468,7 +469,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 +504,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 +1031,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 +1075,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-0.25.0 → guppylang_internals-0.26.0}/src/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-0.25.0 → guppylang_internals-0.26.0}/src/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-0.25.0 → guppylang_internals-0.26.0}/src/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