guppylang-internals 0.22.0__py3-none-any.whl → 0.24.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.22.0"
+__version__ = "0.24.0"

guppylang_internals/cfg/cfg.py

@@ -27,6 +27,9 @@ class BaseCFG(Generic[T]):
     ass_before: Result[DefAssignmentDomain[str]]
     maybe_ass_before: Result[MaybeAssignmentDomain[str]]
 
+    #: Set of variables defined in this CFG
+    assigned_somewhere: set[str]
+
     def __init__(
         self, bbs: list[T], entry_bb: T | None = None, exit_bb: T | None = None
     ):
@@ -38,6 +41,7 @@ class BaseCFG(Generic[T]):
         self.live_before = {}
         self.ass_before = {}
         self.maybe_ass_before = {}
+        self.assigned_somewhere = set()
 
     def ancestors(self, *bbs: T) -> Iterator[T]:
         """Returns an iterator over all ancestors of the given BBs in BFS order."""
@@ -101,6 +105,10 @@ class CFG(BaseCFG[BB]):
         inout_vars: list[str],
     ) -> dict[BB, VariableStats[str]]:
         stats = {bb: bb.compute_variable_stats() for bb in self.bbs}
+        # Locals are variables that are assigned somewhere inside the function
+        self.assigned_somewhere = def_ass_before.union(
+            maybe_ass_before, (x for bb in self.bbs for x in stats[bb].assigned)
+        )
         # Mark all borrowed variables as implicitly used in the exit BB
         stats[self.exit_bb].used |= {x: InoutReturnSentinel(var=x) for x in inout_vars}
         # This also means borrowed variables are always live, so we can use them as the

guppylang_internals/checker/cfg_checker.py

@@ -8,7 +8,7 @@ import ast
 import collections
 from collections.abc import Iterator, Sequence
 from dataclasses import dataclass, field
-from typing import ClassVar, Generic, TypeVar, cast
+from typing import ClassVar, Generic, TypeVar
 
 from guppylang_internals.ast_util import line_col
 from guppylang_internals.cfg.bb import BB
@@ -23,7 +23,6 @@ from guppylang_internals.checker.core import (
 )
 from guppylang_internals.checker.expr_checker import ExprSynthesizer, to_bool
 from guppylang_internals.checker.stmt_checker import StmtChecker
-from guppylang_internals.definition.value import ValueDef
 from guppylang_internals.diagnostic import Error, Note
 from guppylang_internals.error import GuppyError
 from guppylang_internals.tys.param import Parameter
@@ -115,7 +114,7 @@ def check_cfg(
         if bb in compiled:
             # If the BB was already compiled, we just have to check that the signatures
             # match.
-            check_rows_match(input_row, compiled[bb].sig.input_row, bb, globals)
+            check_rows_match(input_row, compiled[bb].sig.input_row, bb)
         else:
             # Otherwise, check the BB and enqueue its successors
             checked_bb = check_bb(
@@ -195,21 +194,6 @@ class BranchTypeError(Error):
         span_label: ClassVar[str] = "This is of type `{ty}`"
         ty: Type
 
-    @dataclass(frozen=True)
-    class GlobalHint(Note):
-        message: ClassVar[str] = (
-            "{ident} may be shadowing a global {defn.description} definition of type "
-            "`{defn.ty}` on some branches"
-        )
-        defn: ValueDef
-
-
-@dataclass(frozen=True)
-class GlobalShadowError(Error):
-    title: ClassVar[str] = "Global variable conditionally shadowed"
-    span_label: ClassVar[str] = "{ident} may be shadowing a global variable"
-    ident: str
-
 
 def check_bb(
     bb: BB,
@@ -245,23 +229,27 @@ def check_bb(
 
     for succ in bb.successors + bb.dummy_successors:
         for x, use_bb in cfg.live_before[succ].items():
-            # Check that the variables requested by the successor are defined
-            if (
-                x not in ctx.locals
-                and x not in ctx.globals
-                and x not in ctx.generic_params
-            ):
-                # If the variable is defined on *some* paths, we can give a more
-                # informative error message
-                if x in cfg.maybe_ass_before[use_bb]:
-                    err = VarMaybeNotDefinedError(use_bb.vars.used[x], x)
-                    if bad_branch := diagnose_maybe_undefined(use_bb, x, cfg):
-                        branch_expr, truth_value = bad_branch
-                        note = VarMaybeNotDefinedError.BadBranch(
-                            branch_expr, x, truth_value
-                        )
-                        err.add_sub_diagnostic(note)
+            # Check that the variables requested by the successor are defined. If `x` is
+            # a local variable, then we must be able to find it in the context.
+            # Following Python, locals are exactly those variables that are defined
+            # somewhere in the function body.
+            if x in cfg.assigned_somewhere:
+                if x not in ctx.locals:
+                    # If the variable is defined on *some* paths, we can give a more
+                    # informative error message
+                    if x in cfg.maybe_ass_before[use_bb]:
+                        err: Error = VarMaybeNotDefinedError(use_bb.vars.used[x], x)
+                        if bad_branch := diagnose_maybe_undefined(use_bb, x, cfg):
+                            branch_expr, truth_value = bad_branch
+                            note = VarMaybeNotDefinedError.BadBranch(
+                                branch_expr, x, truth_value
+                            )
+                            err.add_sub_diagnostic(note)
+                    else:
+                        err = VarNotDefinedError(use_bb.vars.used[x], x)
                     raise GuppyError(err)
+            # If x is not a local, then it must be a global or generic param
+            elif x not in ctx.globals and x not in ctx.generic_params:
                 raise GuppyError(VarNotDefinedError(use_bb.vars.used[x], x))
 
     # Finally, we need to compute the signature of the basic block
@@ -287,9 +275,7 @@ def check_bb(
     return checked_bb
 
 
-def check_rows_match(
-    row1: Row[Variable], row2: Row[Variable], bb: BB, globals: Globals
-) -> None:
+def check_rows_match(row1: Row[Variable], row2: Row[Variable], bb: BB) -> None:
     """Checks that the types of two rows match up.
 
     Otherwise, an error is thrown, alerting the user that a variable has different
@@ -299,10 +285,7 @@ def check_rows_match(
     for x in map1.keys() | map2.keys():
         # If block signature lengths don't match but no undefined error was thrown, some
         # variables may be shadowing global variables.
-        v1 = map1.get(x) or cast(ValueDef, globals[x])
-        assert isinstance(v1, Variable | ValueDef)
-        v2 = map2.get(x) or cast(ValueDef, globals[x])
-        assert isinstance(v2, Variable | ValueDef)
+        v1, v2 = map1[x], map2[x]
         if v1.ty != v2.ty:
             # In the error message, we want to mention the variable that was first
             # defined at the start.
@@ -320,31 +303,9 @@ def check_rows_match(
             # We don't add a location to the type hint for the global variable,
             # since it could lead to cross-file diagnostics (which are not
             # supported) or refer to long function definitions.
-            sub1 = (
-                BranchTypeError.TypeHint(v1.defined_at, v1.ty)
-                if isinstance(v1, Variable)
-                else BranchTypeError.GlobalHint(None, v1)
-            )
-            sub2 = (
-                BranchTypeError.TypeHint(v2.defined_at, v2.ty)
-                if isinstance(v2, Variable)
-                else BranchTypeError.GlobalHint(None, v2)
-            )
-            err.add_sub_diagnostic(sub1)
-            err.add_sub_diagnostic(sub2)
+            err.add_sub_diagnostic(BranchTypeError.TypeHint(v1.defined_at, v1.ty))
+            err.add_sub_diagnostic(BranchTypeError.TypeHint(v2.defined_at, v2.ty))
             raise GuppyError(err)
-        else:
-            # TODO: Remove once https://github.com/CQCL/guppylang/issues/827 is done.
-            # If either is a global variable, don't allow shadowing even if types match.
-            if not (isinstance(v1, Variable) and isinstance(v2, Variable)):
-                local_var = v1 if isinstance(v1, Variable) else v2
-                ident = (
-                    "Expression"
-                    if local_var.name.startswith("%")
-                    else f"Variable `{local_var.name}`"
-                )
-                glob_err = GlobalShadowError(local_var.defined_at, ident)
-                raise GuppyError(glob_err)
 
 
 def diagnose_maybe_undefined(

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
@@ -507,6 +508,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/expr_checker.py

@@ -34,6 +34,7 @@ from guppylang_internals.ast_util import (
     AstNode,
     AstVisitor,
     breaks_in_loop,
+    get_type,
     get_type_opt,
     return_nodes_in_ast,
     with_loc,
@@ -101,8 +102,6 @@ from guppylang_internals.nodes import (
     FieldAccessAndDrop,
     GenericParamValue,
     GlobalName,
-    IterEnd,
-    IterHasNext,
     IterNext,
     LocalCall,
     MakeIter,
@@ -784,14 +783,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 +794,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"
@@ -946,7 +929,7 @@ def check_type_apply(ty: FunctionType, node: ast.Subscript, ctx: Context) -> Ins
         raise GuppyError(err)
 
     return [
-        param.check_arg(arg_from_ast(arg_expr, globals, ctx.generic_params), arg_expr)
+        param.check_arg(arg_from_ast(arg_expr, ctx.parsing_ctx), arg_expr)
         for arg_expr, param in zip(arg_exprs, ty.params, strict=True)
     ]
 
@@ -1232,7 +1215,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)
 
@@ -1309,11 +1299,7 @@ def eval_comptime_expr(node: ComptimeExpr, ctx: Context) -> Any:
         raise GuppyError(ComptimeExprNotCPythonError(node))
 
     try:
-        python_val = eval(  # noqa: S307
-            ast.unparse(node.value),
-            None,
-            DummyEvalDict(ctx, node.value),
-        )
+        python_val = eval(ast.unparse(node.value), DummyEvalDict(ctx, node.value))  # noqa: S307
     except DummyEvalDict.GuppyVarUsedError as e:
         raise GuppyError(ComptimeExprNotStaticError(e.node or node, e.var)) from None
     except Exception as e:

guppylang_internals/checker/func_checker.py

@@ -7,8 +7,8 @@ node straight from the Python AST. We build a CFG, check it, and return a
 
 import ast
 import sys
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, ClassVar
+from dataclasses import dataclass, replace
+from typing import TYPE_CHECKING, ClassVar, cast
 
 from guppylang_internals.ast_util import return_nodes_in_ast, with_loc
 from guppylang_internals.cfg.bb import BB
@@ -17,13 +17,28 @@ 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.definition.common import DefId
+from guppylang_internals.definition.ty import TypeDef
 from guppylang_internals.diagnostic import Error, Help, Note
 from guppylang_internals.engine import DEF_STORE, ENGINE
 from guppylang_internals.error import GuppyError
 from guppylang_internals.experimental import check_capturing_closures_enabled
 from guppylang_internals.nodes import CheckedNestedFunctionDef, NestedFunctionDef
-from guppylang_internals.tys.parsing import parse_function_io_types
-from guppylang_internals.tys.ty import FunctionType, InputFlags, NoneType
+from guppylang_internals.tys.parsing import (
+    TypeParsingCtx,
+    check_function_arg,
+    parse_function_arg_annotation,
+    type_from_ast,
+    type_with_flags_from_ast,
+)
+from guppylang_internals.tys.ty import (
+    ExistentialTypeVar,
+    FuncInput,
+    FunctionType,
+    InputFlags,
+    NoneType,
+    Type,
+    unify,
+)
 
 if sys.version_info >= (3, 12):
     from guppylang_internals.tys.parsing import parse_parameter
@@ -53,6 +68,15 @@ class MissingArgAnnotationError(Error):
     span_label: ClassVar[str] = "Argument requires a type annotation"
 
 
+@dataclass(frozen=True)
+class RecursiveSelfError(Error):
+    title: ClassVar[str] = "Recursive self annotation"
+    span_label: ClassVar[str] = (
+        "Type of `{self_arg}` cannot recursively refer to `Self`"
+    )
+    self_arg: str
+
+
 @dataclass(frozen=True)
 class MissingReturnAnnotationError(Error):
     title: ClassVar[str] = "Missing type annotation"
@@ -67,6 +91,43 @@ class MissingReturnAnnotationError(Error):
         func: str
 
 
+@dataclass(frozen=True)
+class InvalidSelfError(Error):
+    title: ClassVar[str] = "Invalid self annotation"
+    span_label: ClassVar[str] = "`{self_arg}` must be of type `{self_ty}`"
+    self_arg: str
+    self_ty: Type
+
+
+@dataclass(frozen=True)
+class SelfParamsShadowedError(Error):
+    title: ClassVar[str] = "Shadowed generic parameters"
+    span_label: ClassVar[str] = (
+        "Cannot infer type for `{self_arg}` since parameter `{param}` of "
+        "`{ty_defn.name}` is shadowed"
+    )
+    param: str
+    ty_defn: "TypeDef"
+    self_arg: str
+
+    @dataclass(frozen=True)
+    class ExplicitHelp(Help):
+        span_label: ClassVar[str] = (
+            "Consider specifying the type explicitly: `{suggestion}`"
+        )
+
+        @property
+        def suggestion(self) -> str:
+            parent = self._parent
+            assert isinstance(parent, SelfParamsShadowedError)
+            params = (
+                f"[{', '.join(f'?{p.name}' for p in parent.ty_defn.params)}]"
+                if parent.ty_defn.params
+                else ""
+            )
+            return f'{parent.self_arg}: "{parent.ty_defn.name}{params}"'
+
+
 def check_global_func_def(
     func_def: ast.FunctionDef, ty: FunctionType, globals: Globals
 ) -> CheckedCFG[Place]:
@@ -176,9 +237,16 @@ def check_nested_func_def(
     return with_loc(func_def, checked_def)
 
 
-def check_signature(func_def: ast.FunctionDef, globals: Globals) -> FunctionType:
+def check_signature(
+    func_def: ast.FunctionDef, globals: Globals, def_id: DefId | None = None
+) -> FunctionType:
     """Checks the signature of a function definition and returns the corresponding
-    Guppy type."""
+    Guppy type.
+
+    If this is a method, then the `DefId` of the associated parent type should also be
+    passed. This will be used to check or infer the type annotation for the `self`
+    argument.
+    """
     if len(func_def.args.posonlyargs) != 0:
         raise GuppyError(
             UnsupportedError(func_def.args.posonlyargs[0], "Positional-only parameters")
@@ -211,23 +279,29 @@ def check_signature(func_def: ast.FunctionDef, globals: Globals) -> FunctionType
             param = parse_parameter(param_node, i, globals)
             param_var_mapping[param.name] = param
 
-    input_nodes = []
+    # Figure out if this is a method
+    self_defn: TypeDef | None = None
+    if def_id is not None and def_id in DEF_STORE.impl_parents:
+        self_defn = cast(TypeDef, ENGINE.get_checked(DEF_STORE.impl_parents[def_id]))
+        assert isinstance(self_defn, TypeDef)
+
+    inputs = []
     input_names = []
-    for inp in func_def.args.args:
-        ty_ast = inp.annotation
-        if ty_ast is None:
-            raise GuppyError(MissingArgAnnotationError(inp))
-        input_nodes.append(ty_ast)
+    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
+        # since it's not a method so doesn't take `self`.
+        if self_defn and i == 0 and func_def.name != "__new__":
+            input = parse_self_arg(inp, self_defn, ctx)
+            ctx = replace(ctx, self_ty=input.ty)
+        else:
+            ty_ast = inp.annotation
+            if ty_ast is None:
+                raise GuppyError(MissingArgAnnotationError(inp))
+            input = parse_function_arg_annotation(ty_ast, inp.arg, ctx)
+        inputs.append(input)
         input_names.append(inp.arg)
-    inputs, output = parse_function_io_types(
-        input_nodes,
-        func_def.returns,
-        input_names,
-        func_def,
-        globals,
-        param_var_mapping,
-        True,
-    )
+    output = type_from_ast(func_def.returns, ctx)
     return FunctionType(
         inputs,
         output,
@@ -236,6 +310,81 @@ def check_signature(func_def: ast.FunctionDef, globals: Globals) -> FunctionType
     )
 
 
+def parse_self_arg(arg: ast.arg, self_defn: TypeDef, ctx: TypeParsingCtx) -> FuncInput:
+    """Handles parsing of the `self` argument on methods.
+
+    This argument is special since its type annotation may be omitted. Furthermore, if a
+    type is provided then it must match the parent type.
+    """
+    assert self_defn.params is not None
+    if arg.annotation is None:
+        return handle_implicit_self_arg(arg, self_defn, ctx)
+
+    # If the user has provided an annotation for `self`, then we go ahead and parse it.
+    # However, in the annotation the user is also allowed to use `Self`, so we have to
+    # specify a `self_ty` in the context.
+    self_ty_head = self_defn.check_instantiate(
+        [param.to_existential()[0] for param in self_defn.params]
+    )
+    self_ty_placeholder = ExistentialTypeVar.fresh(
+        "Self", copyable=self_ty_head.copyable, droppable=self_ty_head.droppable
+    )
+    assert ctx.self_ty is None
+    ctx = replace(ctx, self_ty=self_ty_placeholder)
+    user_ty, user_flags = type_with_flags_from_ast(arg.annotation, ctx)
+
+    # If the user just annotates `self: Self` then we can fall back to the case where
+    # no annotation is provided at all
+    if user_ty == self_ty_placeholder:
+        return handle_implicit_self_arg(arg, self_defn, ctx, user_flags)
+
+    # Annotations like `self: Foo[Self]` are not allowed (would be an infinite type)
+    if self_ty_placeholder in user_ty.unsolved_vars:
+        raise GuppyError(RecursiveSelfError(arg.annotation, arg.arg))
+
+    # Check that the annotation matches the parent type. We can do this by unifying with
+    # the expected self type where all params are instantiated with unification vars
+    subst = unify(user_ty, self_ty_head, {})
+    if subst is None:
+        raise GuppyError(InvalidSelfError(arg.annotation, arg.arg, self_ty_head))
+
+    return check_function_arg(user_ty, user_flags, arg, arg.arg, ctx)
+
+
+def handle_implicit_self_arg(
+    arg: ast.arg,
+    self_defn: TypeDef,
+    ctx: TypeParsingCtx,
+    flags: InputFlags = InputFlags.NoFlags,
+) -> FuncInput:
+    """Handles the case where no annotation for `self` is provided.
+
+    Generates the most generic annotation that is possible by making the function as
+    generic as the parent type.
+    """
+    # Check that the user hasn't shadowed some of the parent type parameters using a
+    # Python 3.12 style parameter declaration
+    assert self_defn.params is not None
+    shadowed_params = [
+        param for param in self_defn.params if param.name in ctx.param_var_mapping
+    ]
+    if shadowed_params:
+        param = shadowed_params.pop()
+        err = SelfParamsShadowedError(arg, param.name, self_defn, arg.arg)
+        err.add_sub_diagnostic(SelfParamsShadowedError.ExplicitHelp(arg))
+        raise GuppyError(err)
+
+    # The generic params inherited from the parent type should appear first in the
+    # parameter list, so we have to shift the existing ones
+    for name, param in ctx.param_var_mapping.items():
+        ctx.param_var_mapping[name] = param.with_idx(param.idx + len(self_defn.params))
+
+    ctx.param_var_mapping.update({param.name: param for param in self_defn.params})
+    self_args = [param.to_bound() for param in self_defn.params]
+    self_ty = self_defn.check_instantiate(self_args, loc=arg)
+    return check_function_arg(self_ty, flags, arg, arg.arg, ctx)
+
+
 def parse_function_with_docstring(
     func_ast: ast.FunctionDef,
 ) -> tuple[ast.FunctionDef, str | None]:

guppylang_internals/checker/stmt_checker.py

@@ -356,7 +356,7 @@ class StmtChecker(AstVisitor[BBStatement]):
     def visit_AnnAssign(self, node: ast.AnnAssign) -> ast.stmt:
         if node.value is None:
             raise GuppyError(UnsupportedError(node, "Variable declarations"))
-        ty = type_from_ast(node.annotation, self.ctx.globals, self.ctx.generic_params)
+        ty = type_from_ast(node.annotation, self.ctx.parsing_ctx)
         node.value, subst = self._check_expr(node.value, ty)
         assert not ty.unsolved_vars  # `ty` must be closed!
         assert len(subst) == 0