guppylang-internals 0.23.0__py3-none-any.whl → 0.25.0__py3-none-any.whl

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/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/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/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/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/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/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"

guppylang_internals/checker/expr_checker.py

@@ -23,6 +23,7 @@ can be used to infer a type for an expression.
 import ast
 import sys
 import traceback
+from collections.abc import Sequence
 from contextlib import suppress
 from dataclasses import replace
 from types import ModuleType
@@ -34,6 +35,7 @@ from guppylang_internals.ast_util import (
     AstNode,
     AstVisitor,
     breaks_in_loop,
+    get_type,
     get_type_opt,
     return_nodes_in_ast,
     with_loc,
@@ -73,6 +75,7 @@ from guppylang_internals.checker.errors.type_errors import (
     ModuleMemberNotFoundError,
     NonLinearInstantiateError,
     NotCallableError,
+    ParameterInferenceError,
     TupleIndexOutOfBoundsError,
     TypeApplyNotGenericError,
     TypeInferenceError,
@@ -101,8 +104,6 @@ from guppylang_internals.nodes import (
     FieldAccessAndDrop,
     GenericParamValue,
     GlobalName,
-    IterEnd,
-    IterHasNext,
     IterNext,
     LocalCall,
     MakeIter,
@@ -131,7 +132,7 @@ from guppylang_internals.tys.builtin import (
     string_type,
 )
 from guppylang_internals.tys.const import Const, ConstValue
-from guppylang_internals.tys.param import ConstParam, TypeParam
+from guppylang_internals.tys.param import ConstParam, TypeParam, check_all_args
 from guppylang_internals.tys.parsing import arg_from_ast
 from guppylang_internals.tys.subst import Inst, Subst
 from guppylang_internals.tys.ty import (
@@ -150,6 +151,7 @@ from guppylang_internals.tys.ty import (
     parse_function_tensor,
     unify,
 )
+from guppylang_internals.tys.var import ExistentialVar
 
 if TYPE_CHECKING:
     from guppylang_internals.diagnostic import SubDiagnostic
@@ -463,8 +465,15 @@ class ExprSynthesizer(AstVisitor[tuple[ast.expr, Type]]):
         # A `value.attr` attribute access. Unfortunately, the `attr` is just a string,
         # not an AST node, so we have to compute its span by hand. This is fine since
         # linebreaks are not allowed in the identifier following the `.`
+        # 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
         span = to_span(node)
-        attr_span = Span(span.end.shift_left(len(node.attr)), span.end)
+        if span.start.line == span.end.line:
+            attr_span = Span(span.end.shift_left(len(node.attr)), span.end)
+        else:
+            attr_span = span
         if module := self._is_python_module(node.value):
             if node.attr in module.__dict__:
                 val = module.__dict__[node.attr]
@@ -784,14 +793,6 @@ class ExprSynthesizer(AstVisitor[tuple[ast.expr, Type]]):
                 raise GuppyTypeError(err)
         return expr, ty
 
-    def visit_IterHasNext(self, node: IterHasNext) -> tuple[ast.expr, Type]:
-        node.value, ty = self.synthesize(node.value)
-        flags = InputFlags.Owned if not ty.copyable else InputFlags.NoFlags
-        exp_sig = FunctionType([FuncInput(ty, flags)], TupleType([bool_type(), ty]))
-        return self.synthesize_instance_func(
-            node.value, [], "__hasnext__", "an iterator", exp_sig, True
-        )
-
     def visit_IterNext(self, node: IterNext) -> tuple[ast.expr, Type]:
         node.value, ty = self.synthesize(node.value)
         flags = InputFlags.Owned if not ty.copyable else InputFlags.NoFlags
@@ -803,14 +804,6 @@ class ExprSynthesizer(AstVisitor[tuple[ast.expr, Type]]):
             node.value, [], "__next__", "an iterator", exp_sig, True
         )
 
-    def visit_IterEnd(self, node: IterEnd) -> tuple[ast.expr, Type]:
-        node.value, ty = self.synthesize(node.value)
-        flags = InputFlags.Owned if not ty.copyable else InputFlags.NoFlags
-        exp_sig = FunctionType([FuncInput(ty, flags)], NoneType())
-        return self.synthesize_instance_func(
-            node.value, [], "__end__", "an iterator", exp_sig, True
-        )
-
     def visit_ListComp(self, node: ast.ListComp) -> tuple[ast.expr, Type]:
         raise InternalGuppyError(
             "BB contains `ListComp`. Should have been removed during CFG"
@@ -945,10 +938,9 @@ def check_type_apply(ty: FunctionType, node: ast.Subscript, ctx: Context) -> Ins
         err.add_sub_diagnostic(WrongNumberOfArgsError.SignatureHint(None, ty))
         raise GuppyError(err)
 
-    return [
-        param.check_arg(arg_from_ast(arg_expr, globals, ctx.generic_params), arg_expr)
-        for arg_expr, param in zip(arg_exprs, ty.params, strict=True)
-    ]
+    inst = [arg_from_ast(node, ctx.parsing_ctx) for node in arg_exprs]
+    check_all_args(ty.params, inst, "", node, arg_exprs)
+    return inst
 
 
 def check_num_args(
@@ -992,15 +984,17 @@ def type_check_args(
     comptime_args = iter(func_ty.comptime_args)
     for inp, func_inp in zip(inputs, func_ty.inputs, strict=True):
         a, s = ExprChecker(ctx).check(inp, func_inp.ty.substitute(subst), "argument")
+        subst |= s
         if InputFlags.Inout in func_inp.flags and isinstance(a, PlaceNode):
             a.place = check_place_assignable(
                 a.place, ctx, a, "able to borrow subscripted elements"
             )
         if InputFlags.Comptime in func_inp.flags:
             comptime_arg = next(comptime_args)
-            s = check_comptime_arg(a, comptime_arg.const, func_inp.ty, s)
+            const = comptime_arg.const.substitute(subst)
+            s = check_comptime_arg(a, const, func_inp.ty.substitute(subst), subst)
+            subst |= s
         new_args.append(a)
-        subst |= s
     assert next(comptime_args, None) is None
 
     # If the argument check succeeded, this means that we must have found instantiations
@@ -1120,7 +1114,7 @@ def synthesize_call(
 
     # Success implies that the substitution is closed
     assert all(not t.unsolved_vars for t in subst.values())
-    inst = [subst[v].to_arg() for v in free_vars]
+    inst = check_all_solved(subst, free_vars, func_ty, node)
 
     # Finally, check that the instantiation respects the linearity requirements
     check_inst(func_ty, inst, node)
@@ -1199,7 +1193,7 @@ def check_call(
 
     # Success implies that the substitution is closed
     assert all(not t.unsolved_vars for t in subst.values())
-    inst = [subst[v].to_arg() for v in free_vars]
+    inst = check_all_solved(subst, free_vars, func_ty, node)
     subst = {v: t for v, t in subst.items() if v in ty.unsolved_vars}
 
     # Finally, check that the instantiation respects the linearity requirements
@@ -1208,12 +1202,37 @@ def check_call(
     return inputs, subst, inst
 
 
+def check_all_solved(
+    subst: Subst,
+    free_vars: Sequence[ExistentialVar],
+    func_ty: FunctionType,
+    loc: AstNode,
+) -> Inst:
+    """Checks that a substitution solves all parameters of a function.
+
+    Using 3.12 generic syntax, users can declare parameters that don't occur in the
+    signature. Those will remain unsolved, even after unifying all function arguments,
+    so we have to perform this extra check.
+
+    Returns an instantiation of all free variables, or emits a user error if some are
+    not solved.
+    """
+    for v in free_vars:
+        if v not in subst:
+            err = ParameterInferenceError(loc, v.display_name)
+            err.add_sub_diagnostic(ParameterInferenceError.SignatureHint(None, func_ty))
+            raise GuppyTypeInferenceError(err)
+    return [subst[v].to_arg() for v in free_vars]
+
+
 def check_inst(func_ty: FunctionType, inst: Inst, node: AstNode) -> None:
     """Checks if an instantiation is valid.
 
     Makes sure that the linearity requirements are satisfied.
     """
     for param, arg in zip(func_ty.params, inst, strict=True):
+        param = param.instantiate_bounds(inst)
+
         # Give a more informative error message for linearity issues
         if isinstance(param, TypeParam) and isinstance(arg, TypeArg):
             if param.must_be_copyable and not arg.ty.copyable:
@@ -1232,7 +1251,14 @@ def instantiate_poly(node: ast.expr, ty: FunctionType, inst: Inst) -> ast.expr:
     """Instantiates quantified type arguments in a function."""
     assert len(ty.params) == len(inst)
     if len(inst) > 0:
-        node = with_loc(node, TypeApply(value=with_type(ty, node), inst=inst))
+        # Partial applications need to be instantiated on the inside
+        if isinstance(node, PartialApply):
+            full_ty = get_type(node.func)
+            assert isinstance(full_ty, FunctionType)
+            assert full_ty.params == ty.params
+            node.func = instantiate_poly(node.func, full_ty, inst)
+        else:
+            node = with_loc(node, TypeApply(value=with_type(ty, node), inst=inst))
         return with_type(ty.instantiate(inst), node)
     return with_type(ty, node)