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

guppylang_internals-0.25.0/CHANGELOG.md

@@ -0,0 +1,123 @@
+# Changelog
+
+First release of `guppylang_internals` package containing refactored out internal components
+from `guppylang`.
+
+## [0.25.0](https://github.com/CQCL/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/CQCL/guppylang/issues/1287)) ([439ff1a](https://github.com/CQCL/guppylang/commit/439ff1ae6bd872bb7a6eb5441110d2febebd1e47))
+* modifiers in CFG and its type checker (experimental) ([#1281](https://github.com/CQCL/guppylang/issues/1281)) ([fe85018](https://github.com/CQCL/guppylang/commit/fe8501854507c3c43cec2f26bba75198766a4a17))
+* Turn type parameters into dependent telescopes ([#1154](https://github.com/CQCL/guppylang/issues/1154)) ([b56e056](https://github.com/CQCL/guppylang/commit/b56e056a6b4795c778ed8124a09a194fb1d97dda))
+* update hugr, tket-exts and tket ([#1305](https://github.com/CQCL/guppylang/issues/1305)) ([6990d85](https://github.com/CQCL/guppylang/commit/6990d850170e6901f60ef1d1e718c99349105b56))
+* Use `borrow_array` instead of `value_array` for array lowering ([#1166](https://github.com/CQCL/guppylang/issues/1166)) ([f9ef42b](https://github.com/CQCL/guppylang/commit/f9ef42b2baf61c3e1c2cfcf7bd1f3bcac33a1a25))
+
+
+### Bug Fixes
+
+* compilation of affine-bounded type variables ([#1308](https://github.com/CQCL/guppylang/issues/1308)) ([49ecb49](https://github.com/CQCL/guppylang/commit/49ecb497bf450d0853baec1de9c516a3804a80eb))
+* Detect unsolved generic parameters even if they are unused ([#1279](https://github.com/CQCL/guppylang/issues/1279)) ([f830db0](https://github.com/CQCL/guppylang/commit/f830db00c416cfc1e9fe7ec70c612b6b558aa740)), closes [#1273](https://github.com/CQCL/guppylang/issues/1273)
+* Fix bug in symbolic pytket circuit loading with arrays ([#1302](https://github.com/CQCL/guppylang/issues/1302)) ([e6b90e8](https://github.com/CQCL/guppylang/commit/e6b90e8e4d275d36514a75e87eb097383495a291)), closes [#1298](https://github.com/CQCL/guppylang/issues/1298)
+* Improve track_hugr_side_effects, adding Order edges from/to Input/Output ([#1311](https://github.com/CQCL/guppylang/issues/1311)) ([3c6ce7a](https://github.com/CQCL/guppylang/commit/3c6ce7aaf7a1c93c6412501976fc97afd61a062d))
+* multiline loop arguments  ([#1309](https://github.com/CQCL/guppylang/issues/1309)) ([836ef72](https://github.com/CQCL/guppylang/commit/836ef722d8f8bdb02c56e5f06934246a718e68d3))
+
+## [0.24.0](https://github.com/CQCL/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/CQCL/guppylang/issues/1192)) ([51f5a2b](https://github.com/CQCL/guppylang/commit/51f5a2b3a9b06bc4ab054f32a4d07f7395df8ff4))
+
+
+### Bug Fixes
+
+* Add init to CompilationEngine; don't trash additional_extensions ([#1256](https://github.com/CQCL/guppylang/issues/1256)) ([e413748](https://github.com/CQCL/guppylang/commit/e413748532db3895cab4925a222177a4fa3fd61b))
+* Allow generic specialization of methods ([#1206](https://github.com/CQCL/guppylang/issues/1206)) ([93936cc](https://github.com/CQCL/guppylang/commit/93936cc275c56dd856d11fabc7aac20176304147)), closes [#1182](https://github.com/CQCL/guppylang/issues/1182)
+* Correctly update borrowed values after calls and catch cases where it's impossible ([#1253](https://github.com/CQCL/guppylang/issues/1253)) ([3ec5462](https://github.com/CQCL/guppylang/commit/3ec54627729b49689da006a743e9e2c359cd3728))
+* Fix `nat` constructor in comptime functions ([#1258](https://github.com/CQCL/guppylang/issues/1258)) ([e257b6f](https://github.com/CQCL/guppylang/commit/e257b6fc2fe3793d6d8f63feca83bf5ed6643673))
+* Fix incorrect leak error for borrowing functions in comptime ([#1252](https://github.com/CQCL/guppylang/issues/1252)) ([855244e](https://github.com/CQCL/guppylang/commit/855244e2d5e3aeb04c2028f9f2310dba0e74210a)), closes [#1249](https://github.com/CQCL/guppylang/issues/1249)
+* wasm module updates based on tested lowering ([#1230](https://github.com/CQCL/guppylang/issues/1230)) ([657cea2](https://github.com/CQCL/guppylang/commit/657cea27af00a9c02e8d1a3190db535bbd1e7981))
+
+
+### Miscellaneous Chores
+
+* Delete unused old iterator AST nodes ([#1215](https://github.com/CQCL/guppylang/issues/1215)) ([2310897](https://github.com/CQCL/guppylang/commit/231089750e33cf70754e5218feed64053c558c17))
+
+## [0.23.0](https://github.com/CQCL/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/CQCL/guppylang/issues/1169)) ([a6a91ca](https://github.com/CQCL/guppylang/commit/a6a91ca32ad7c67bf1d733eb26c016a2662256ef))
+* Fix scoping issues with comprehensions in comptime expressions ([#1218](https://github.com/CQCL/guppylang/issues/1218)) ([0b990e2](https://github.com/CQCL/guppylang/commit/0b990e2b006c31352675004aec63a857f03a0793))
+
+
+### Documentation
+
+* use results sequence protocol for simplicity ([#1208](https://github.com/CQCL/guppylang/issues/1208)) ([f9c1aee](https://github.com/CQCL/guppylang/commit/f9c1aee38776c678660ede5495989ac4d75baaeb))
+
+## [0.22.0](https://github.com/CQCL/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/CQCL/guppylang/issues/1105)) ([34c546c](https://github.com/CQCL/guppylang/commit/34c546c3b5787beb839687fdbf4db8bc94f36c4a)), closes [#1076](https://github.com/CQCL/guppylang/issues/1076)
+* Allow custom start and step in `range` ([#1157](https://github.com/CQCL/guppylang/issues/1157)) ([a1b9333](https://github.com/CQCL/guppylang/commit/a1b9333712c74270d5efaaa72f83d6b09047c068))
+* Improve codegen for array unpacking ([#1106](https://github.com/CQCL/guppylang/issues/1106)) ([f375097](https://github.com/CQCL/guppylang/commit/f3750973a719b03d27668a3ae39f58c8424deffc))
+* Insert drop ops for affine values ([#1090](https://github.com/CQCL/guppylang/issues/1090)) ([083133e](https://github.com/CQCL/guppylang/commit/083133e809873fce265bb78547fc3e519cb66ea1))
+
+
+### Bug Fixes
+
+* Fix builtins mock escaping the tracing scope ([#1161](https://github.com/CQCL/guppylang/issues/1161)) ([a27a5c1](https://github.com/CQCL/guppylang/commit/a27a5c19560d76e46678f846476ea86e873ac8ac))
+
+## [0.21.1](https://github.com/CQCL/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/CQCL/guppylang/issues/1146)) ([d8474d8](https://github.com/CQCL/guppylang/commit/d8474d8af3d394275268cd3d0754ff06ecb9bcc2)), closes [#1145](https://github.com/CQCL/guppylang/issues/1145)
+* Support `None` value ([#1149](https://github.com/CQCL/guppylang/issues/1149)) ([7f606c7](https://github.com/CQCL/guppylang/commit/7f606c778d98312a0d1c4a9c7a27448c24d80585)), closes [#1148](https://github.com/CQCL/guppylang/issues/1148)
+
+
+### Documentation
+
+* Fix docs build ([#1142](https://github.com/CQCL/guppylang/issues/1142)) ([4dfd575](https://github.com/CQCL/guppylang/commit/4dfd575bcdfdf1e2db4e61f2f406fff27e0c08f7))
+
+## [0.21.0](https://github.com/CQCL/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/CQCL/guppylang/issues/1126)) ([81d50c0](https://github.com/CQCL/guppylang/commit/81d50c0a24f55eca48d62e4b0275ef2126c5e626))

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: guppylang-internals
-Version: 0.23.0
+Version: 0.25.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,8 +219,8 @@ 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.13.1
-Requires-Dist: tket-exts~=0.10.0
+Requires-Dist: hugr~=0.14.1
+Requires-Dist: tket-exts~=0.12.0
 Requires-Dist: typing-extensions<5,>=4.9.0
 Provides-Extra: pytket
 Requires-Dist: pytket>=1.34; extra == 'pytket'
@@ -228,7 +228,7 @@ Description-Content-Type: text/markdown
 
 # guppylang-internals
 
-This packages contains the internals of the Guppy compiler. 
+This packages contains the internals of the Guppy compiler.
 
 See `guppylang` for the package providing the user-facing language frontend.
 

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

@@ -1,6 +1,6 @@
 # guppylang-internals
 
-This packages contains the internals of the Guppy compiler. 
+This packages contains the internals of the Guppy compiler.
 
 See `guppylang` for the package providing the user-facing language frontend.
 

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

@@ -1,6 +1,6 @@
 [project]
 name = "guppylang-internals"
-version = "0.23.0"
+version = "0.25.0"
 requires-python = ">=3.10,<4"
 description = "Compiler internals for `guppylang` package."
 license = { file = "LICENCE" }
@@ -34,8 +34,8 @@ classifiers = [
 
 dependencies = [
     "typing-extensions >=4.9.0,<5",
-    "tket-exts ~= 0.10.0",
-    "hugr ~= 0.13.1",
+    "tket-exts ~= 0.12.0",
+    "hugr ~= 0.14.1",
 ]
 
 [project.optional-dependencies]

{guppylang_internals-0.23.0 → guppylang_internals-0.25.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.23.0"
+__version__ = "0.25.0"

{guppylang_internals-0.23.0 → guppylang_internals-0.25.0}/src/guppylang_internals/ast_util.py

@@ -106,6 +106,14 @@ def return_nodes_in_ast(node: Any) -> list[ast.Return]:
     return cast(list[ast.Return], found)
 
 
+def loop_in_ast(node: Any) -> list[ast.For | ast.While]:
+    """Returns all `For` and `While` nodes occurring in an AST."""
+    found = find_nodes(
+        lambda n: isinstance(n, ast.For | ast.While), node, {ast.FunctionDef}
+    )
+    return cast(list[ast.For | ast.While], found)
+
+
 def breaks_in_loop(node: Any) -> list[ast.Break]:
     """Returns all `Break` nodes occurring in a loop.
 
@@ -117,6 +125,19 @@ def breaks_in_loop(node: Any) -> list[ast.Break]:
     return cast(list[ast.Break], found)
 
 
+def loop_controls_in_loop(node: Any) -> list[ast.Break | ast.Continue]:
+    """Returns all `Break` and `Continue` nodes occurring in a loop.
+
+    Note that breaks in nested loops are excluded.
+    """
+    found = find_nodes(
+        lambda n: isinstance(n, ast.Break | ast.Continue),
+        node,
+        {ast.For, ast.While, ast.FunctionDef},
+    )
+    return cast(list[ast.Break | ast.Continue], found)
+
+
 class ContextAdjuster(ast.NodeTransformer):
     """Updates the `ast.Context` indicating if expressions occur on the LHS or RHS."""
 

{guppylang_internals-0.23.0 → guppylang_internals-0.25.0}/src/guppylang_internals/cfg/bb.py

@@ -13,6 +13,7 @@ from guppylang_internals.nodes import (
     DesugaredGenerator,
     DesugaredGeneratorExpr,
     DesugaredListComp,
+    ModifiedBlock,
     NestedFunctionDef,
 )
 
@@ -44,6 +45,7 @@ BBStatement = (
     | ast.Expr
     | ast.Return
     | NestedFunctionDef
+    | ModifiedBlock
 )
 
 
@@ -219,3 +221,21 @@ class VariableVisitor(ast.NodeVisitor):
 
         # The name of the function is now assigned
         self.stats.assigned[node.name] = node
+
+    def visit_ModifiedBlock(self, node: ModifiedBlock) -> None:
+        for item in node.control:
+            self.visit(item)
+        for item in node.power:
+            self.visit(item)
+
+        # Similarly to nested functions
+        from guppylang_internals.cfg.analysis import LivenessAnalysis
+
+        stats = {bb: bb.compute_variable_stats() for bb in node.cfg.bbs}
+        live = LivenessAnalysis(stats).run(node.cfg.bbs)
+        assigned_before_in_bb = self.stats.assigned.keys()
+        self.stats.used |= {
+            x: using_bb.vars.used[x]
+            for x, using_bb in live[node.cfg.entry_bb].items()
+            if x not in assigned_before_in_bb
+        }

{guppylang_internals-0.23.0 → guppylang_internals-0.25.0}/src/guppylang_internals/cfg/builder.py

@@ -9,6 +9,8 @@ from guppylang_internals.ast_util import (
     AstVisitor,
     ContextAdjuster,
     find_nodes,
+    loop_controls_in_loop,
+    return_nodes_in_ast,
     set_location_from,
     template_replace,
     with_loc,
@@ -16,19 +18,34 @@ from guppylang_internals.ast_util import (
 from guppylang_internals.cfg.bb import BB, BBStatement
 from guppylang_internals.cfg.cfg import CFG
 from guppylang_internals.checker.core import Globals
-from guppylang_internals.checker.errors.generic import ExpectedError, UnsupportedError
+from guppylang_internals.checker.errors.generic import (
+    ExpectedError,
+    UnexpectedInWithBlockError,
+    UnknownModifierError,
+    UnsupportedError,
+)
+from guppylang_internals.checker.errors.type_errors import WrongNumberOfArgsError
 from guppylang_internals.diagnostic import Error
 from guppylang_internals.error import GuppyError, InternalGuppyError
-from guppylang_internals.experimental import check_lists_enabled
+from guppylang_internals.experimental import (
+    check_lists_enabled,
+    check_modifiers_enabled,
+)
 from guppylang_internals.nodes import (
     ComptimeExpr,
+    Control,
+    Dagger,
     DesugaredGenerator,
     DesugaredGeneratorExpr,
     DesugaredListComp,
     IterNext,
     MakeIter,
+    ModifiedBlock,
+    Modifier,
     NestedFunctionDef,
+    Power,
 )
+from guppylang_internals.span import Span, to_span
 from guppylang_internals.tys.ty import NoneType
 
 # In order to build expressions, need an endless stream of unique temporary variables
@@ -135,7 +152,10 @@ class CFGBuilder(AstVisitor[BB | None]):
         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.
         """
-        if not isinstance(node, NestedFunctionDef) and node.value is not None:
+        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
@@ -265,6 +285,84 @@ class CFGBuilder(AstVisitor[BB | None]):
         bb.statements.append(new_node)
         return bb
 
+    def visit_With(self, node: ast.With, bb: BB, jumps: Jumps) -> BB | None:
+        check_modifiers_enabled(node)
+        self._validate_modified_block(node)
+
+        cfg = CFGBuilder().build(node.body, True, self.globals)
+        new_node = ModifiedBlock(
+            cfg=cfg,
+            **dict(ast.iter_fields(node)),
+        )
+
+        for item in node.items:
+            item.context_expr, bb = ExprBuilder.build(item.context_expr, self.cfg, bb)
+            modifier = self._handle_withitem(item)
+            new_node.push_modifier(modifier)
+
+        set_location_from(new_node, node)
+        bb.statements.append(new_node)
+        return bb
+
+    def _handle_withitem(self, node: ast.withitem) -> Modifier:
+        # Check that `as` notation is not used
+        if node.optional_vars is not None:
+            span = Span(
+                to_span(node.context_expr).start, to_span(node.optional_vars).end
+            )
+            raise GuppyError(UnsupportedError(span, "`as` expression", singular=True))
+
+        e = node.context_expr
+        modifier: Modifier
+        match e:
+            case ast.Name(id="dagger"):
+                modifier = Dagger(e)
+            case ast.Call(func=ast.Name(id="dagger")):
+                if len(e.args) != 0:
+                    span = Span(to_span(e.args[0]).start, to_span(e.args[-1]).end)
+                    raise GuppyError(WrongNumberOfArgsError(span, 0, len(e.args)))
+                modifier = Dagger(e)
+            case ast.Call(func=ast.Name(id="control")):
+                if len(e.args) == 0:
+                    span = Span(to_span(e.func).end, to_span(e).end)
+                    raise GuppyError(WrongNumberOfArgsError(span, 1, len(e.args)))
+                modifier = Control(e, e.args)
+            case ast.Call(func=ast.Name(id="power")):
+                if len(e.args) == 0:
+                    span = Span(to_span(e.func).end, to_span(e).end)
+                    raise GuppyError(WrongNumberOfArgsError(span, 1, len(e.args)))
+                elif len(e.args) != 1:
+                    span = Span(to_span(e.args[1]).start, to_span(e.args[-1]).end)
+                    raise GuppyError(WrongNumberOfArgsError(span, 1, len(e.args)))
+                modifier = Power(e, e.args[0])
+            case _:
+                raise GuppyError(UnknownModifierError(e))
+        return modifier
+
+    def _validate_modified_block(self, node: ast.With) -> None:
+        # Check if the body contains a return statement.
+        return_in_body = return_nodes_in_ast(node)
+        if len(return_in_body) != 0:
+            err = UnexpectedInWithBlockError(return_in_body[0], "return", "Return")
+            span = Span(
+                to_span(node.items[0].context_expr).start,
+                to_span(node.items[-1].context_expr).end,
+            )
+            err.add_sub_diagnostic(UnexpectedInWithBlockError.Modifier(span))
+            raise GuppyError(err)
+
+        loop_controls_in_body = loop_controls_in_loop(node)
+        if len(loop_controls_in_body) != 0:
+            lc = loop_controls_in_body[0]
+            kind = lc.__class__.__name__
+            err = UnexpectedInWithBlockError(lc, "loop control", kind)
+            span = Span(
+                to_span(node.items[0].context_expr).start,
+                to_span(node.items[-1].context_expr).end,
+            )
+            err.add_sub_diagnostic(UnexpectedInWithBlockError.Modifier(span))
+            raise GuppyError(err)
+
     def generic_visit(self, node: ast.AST, bb: BB, jumps: Jumps) -> BB | None:
         # When adding support for new statements, we have to remember to use the
         # ExprBuilder to transform all included expressions!

{guppylang_internals-0.23.0 → guppylang_internals-0.25.0}/src/guppylang_internals/checker/core.py

@@ -54,6 +54,7 @@ from guppylang_internals.tys.ty import (
 
 if TYPE_CHECKING:
     from guppylang_internals.definition.struct import StructField
+    from guppylang_internals.tys.parsing import TypeParsingCtx
 
 
 #: A "place" is a description for a storage location of a local value that users
@@ -116,6 +117,10 @@ class Variable:
         """Returns a new `Variable` instance with an updated definition location."""
         return replace(self, defined_at=node)
 
+    def add_flags(self, flags: InputFlags) -> "Variable":
+        """Returns a new `Variable` instance with updated flags."""
+        return replace(self, flags=self.flags | flags)
+
 
 @dataclass(frozen=True, kw_only=True)
 class ComptimeVariable(Variable):
@@ -507,6 +512,13 @@ class Context(NamedTuple):
     locals: Locals[str, Variable]
     generic_params: dict[str, Parameter]
 
+    @property
+    def parsing_ctx(self) -> "TypeParsingCtx":
+        """A type parsing context derived from this checking context."""
+        from guppylang_internals.tys.parsing import TypeParsingCtx
+
+        return TypeParsingCtx(self.globals, self.generic_params)
+
 
 class DummyEvalDict(dict[str, Any]):
     """A custom dict that can be passed to `eval` to give better error messages.

{guppylang_internals-0.23.0 → guppylang_internals-0.25.0}/src/guppylang_internals/checker/errors/generic.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
 
 
 @dataclass(frozen=True)
@@ -43,3 +43,34 @@ class ExpectedError(Error):
     @property
     def extra(self) -> str:
         return f", got {self.got}" if self.got else ""
+
+
+@dataclass(frozen=True)
+class UnknownModifierError(Error):
+    title: ClassVar[str] = "Unknown modifier"
+    span_label: ClassVar[str] = (
+        "Expected one of {{dagger, control(...), or power(...)}}"
+    )
+
+
+@dataclass(frozen=True)
+class UnexpectedInWithBlockError(Error):
+    title: ClassVar[str] = "Unexpected {kind}"
+    span_label: ClassVar[str] = "{things} found in a `With` block"
+    kind: str
+    things: str
+
+    @dataclass(frozen=True)
+    class Modifier(Note):
+        span_label: ClassVar[str] = "modifier is used here"
+
+
+@dataclass(frozen=True)
+class InvalidUnderDagger(Error):
+    title: ClassVar[str] = "Invalid expression in dagger"
+    span_label: ClassVar[str] = "{things} found in a dagger context"
+    things: str
+
+    @dataclass(frozen=True)
+    class Dagger(Note):
+        span_label: ClassVar[str] = "dagger modifier is used here"

{guppylang_internals-0.23.0 → guppylang_internals-0.25.0}/src/guppylang_internals/checker/errors/type_errors.py

@@ -95,6 +95,20 @@ class TypeInferenceError(Error):
     unsolved_ty: Type
 
 
+@dataclass(frozen=True)
+class ParameterInferenceError(Error):
+    title: ClassVar[str] = "Cannot infer generic parameter"
+    span_label: ClassVar[str] = (
+        "Cannot infer generic parameter `{param}` of this function"
+    )
+    param: str
+
+    @dataclass(frozen=True)
+    class SignatureHint(Note):
+        message: ClassVar[str] = "Function signature is `{sig}`"
+        sig: FunctionType
+
+
 @dataclass(frozen=True)
 class IllegalConstant(Error):
     title: ClassVar[str] = "Unsupported constant"