feat!: Explicit effects system, prevent calls from annotated funcs to those with fewer effects

guppylang-internals/src/guppylang_internals/checker/cfg_checker.py

@@ -15,6 +15,7 @@
 from guppylang_internals.cfg.cfg import CFG, BaseCFG
 from guppylang_internals.checker.core import (
     Context,
+    EffectLimitDecl,
     Globals,
     Locals,
     Place,
@@ -76,6 +77,7 @@ def check_cfg(
     generic_args: dict[str, Argument],
     func_name: str,
     globals: Globals,
+    max_effects_from: EffectLimitDecl | None,
     first_modifier_node: ast.expr | None = None,
 ) -> CheckedCFG[Place]:
     """Instantiates a control-flow graph with the given `generic_args` and then type
@@ -100,7 +102,13 @@ def check_cfg(
     # We start by compiling the entry BB
     checked_cfg: CheckedCFG[Variable] = CheckedCFG([v.ty for v in inputs], return_ty)
     checked_cfg.entry_bb = check_bb(
-        cfg.entry_bb, checked_cfg, inputs, return_ty, generic_args, globals
+        cfg.entry_bb,
+        checked_cfg,
+        inputs,
+        return_ty,
+        generic_args,
+        globals,
+        max_effects_from=max_effects_from,
     )
     compiled = {cfg.entry_bb: checked_cfg.entry_bb}
 
@@ -127,7 +135,13 @@ def check_cfg(
         else:
             # Otherwise, check the BB and enqueue its successors
             checked_bb = check_bb(
-                bb, checked_cfg, input_row, return_ty, generic_args, globals
+                bb,
+                checked_cfg,
+                input_row,
+                return_ty,
+                generic_args,
+                globals,
+                max_effects_from=max_effects_from,
             )
             queue += [
                 # We enumerate the successor starting from the back, so we start with
@@ -237,6 +251,7 @@ def check_bb(
     return_ty: Type,
     generic_args: dict[str, Argument],
     globals: Globals,
+    max_effects_from: EffectLimitDecl | None,
 ) -> CheckedBB[Variable]:
     cfg = bb.containing_cfg
 
@@ -261,7 +276,9 @@ def check_bb(
         raise GuppyError(_assigned_in_modifier_error(x, use, assignment))
 
     # Check the basic block
-    ctx = Context(globals, Locals({v.name: v for v in inputs}), generic_args)
+    ctx = Context(
+        globals, Locals({v.name: v for v in inputs}), generic_args, max_effects_from
+    )
     checked_stmts = StmtChecker(ctx, bb, return_ty).check_stmts(bb.statements)
 
     # If we branch, we also have to check the branch predicate

guppylang-internals/src/guppylang_internals/checker/core.py

@@ -3,7 +3,7 @@
 import itertools
 from collections.abc import Iterable, Iterator
 from dataclasses import dataclass, field, replace
-from functools import cache, cached_property
+from functools import cache, cached_property, reduce
 from types import FrameType
 from typing import (
     TYPE_CHECKING,
@@ -26,9 +26,12 @@
 )
 from guppylang_internals.engine import BUILTIN_DEFS, DEF_STORE, ENGINE
 from guppylang_internals.error import InternalGuppyError, RequiresMonomorphizationError
+from guppylang_internals.span import Span, to_span
+from guppylang_internals.tys import Effect
 from guppylang_internals.tys.arg import Argument, ConstArg, TypeArg
 from guppylang_internals.tys.const import BoundConstVar, ConstValue, ExistentialConstVar
 from guppylang_internals.tys.ty import (
+    FunctionType,
     InputFlags,
     StructType,
     Type,
@@ -441,13 +444,67 @@ def items(self) -> Iterable[tuple[VId, V]]:
         return itertools.chain(self.vars.items(), parent_items)
 
 
+@dataclass(frozen=True)
+class EffectLimitDecl:
+    """Records a declaration limiting the effects that may be used in a Context"""
+
+    effects: list[Effect]
+    decl: ast.expr | Span
+    decl_name: str
+
+    @classmethod
+    def for_def(
+        cls, ty: FunctionType, func_def: ast.FunctionDef
+    ) -> "EffectLimitDecl | None":
+        if ty.declared_effects is None:
+            return None
+        if (deco := _find_guppy_decorator(func_def.decorator_list)) is not None:
+            decl = deco
+        else:
+            # Could not identify decorator, so include all in context; union with
+            # returns will include name etc. inbetween but avoid the function body.
+            elems = func_def.decorator_list
+            if func_def.returns is not None:
+                elems += [func_def.returns]
+
+            def union(s1: Span, s2: Span) -> Span:
+                r = s1 | s2
+                assert r is not None  # Function def should not cross file boundary
+                return r
+
+            decl = reduce(union, (to_span(e) for e in elems))
+
+        return EffectLimitDecl(
+            ty.declared_effects,
+            decl,
+            func_def.name,
+        )
+
+
+def _find_guppy_decorator(decorators: list[ast.expr]) -> ast.expr | None:
+    for d in decorators:
+        if (
+            isinstance(d, ast.Call)
+            and isinstance(d.func, ast.Name)
+            and d.func.id == "guppy"
+        ):
+            return d
+        if isinstance(d, ast.Name) and d.id == "guppy":
+            return d
+    return None
+
+
 class Context(NamedTuple):
     """The type checking context."""
 
     globals: Globals
     locals: Locals[str, Variable]
     generic_param_inst: dict[str, Argument]
 
+    """If not None, the effect constraints that function calls in this context must
+    respect, together with the AST node that gives rise to said constraint"""
+    max_effects_from: EffectLimitDecl | None = None
+
     @property
     def parsing_ctx(self) -> "TypeParsingCtx":
         """A type parsing context derived from this checking context."""

guppylang-internals/src/guppylang_internals/checker/errors/type_errors.py

@@ -4,6 +4,7 @@
 from typing import TYPE_CHECKING, ClassVar
 
 from guppylang_internals.diagnostic import Error, Help, Note
+from guppylang_internals.tys import Effect
 
 if TYPE_CHECKING:
     from guppylang_internals.definition.util import CheckedField
@@ -68,6 +69,39 @@ class ConstMismatchError(Error):
     actual: Const
 
 
+@dataclass(frozen=True)
+class TooManyEffectsError(Error):
+    title: ClassVar[str] = "Too many effects"
+    span_label: ClassVar[str] = "{target} not allowed inside `{in_func}`"
+    callee: str | FunctionType
+    effects: list[Effect]
+    in_func: str
+
+    @property
+    def target(self) -> str:
+        if isinstance(self.callee, str):
+            return f"Call to `{self.callee}`" + self.note_effects()
+        msg = f"Callee of type `{self.callee}`"
+        if self.callee.declared_effects is None:
+            # FunctionType that will not display any effects, so list separately
+            msg += self.note_effects()
+        return msg
+
+    def note_effects(self) -> str:
+        return f" has effects `{Effect.format_list(self.effects)}`"
+
+    @dataclass(frozen=True)
+    class MaxFromDecl(Note):
+        span_label: ClassVar[str] = "Allowed effects {allowed_effects_str}declared here"
+        allowed_effects: list[Effect] | None
+
+        @property
+        def allowed_effects_str(self) -> str:
+            if self.allowed_effects is None:
+                return ""
+            return "`" + Effect.format_list(self.allowed_effects) + "` "
+
+
 @dataclass(frozen=True)
 class AssignFieldTypeMismatchError(Error):
     title: ClassVar[str] = "Type mismatch"

guppylang-internals/src/guppylang_internals/checker/expr_checker.py

@@ -83,6 +83,7 @@
     NonLinearInstantiateError,
     NotCallableError,
     ParameterInferenceError,
+    TooManyEffectsError,
     TupleIndexOutOfBoundsError,
     TypeApplyNotGenericError,
     TypeInferenceError,
@@ -1327,6 +1328,32 @@ def check_comptime_arg(
     return subst
 
 
+def _check_effects(func_ty: FunctionType, ctx: Context, node: AstNode) -> None:
+    """Checks that a function call (AST provided) to a specified FunctionType
+    respects the effect constraints in the context."""
+    if (mf := ctx.max_effects_from) is None:
+        return
+    surplus_effects = [e for e in func_ty.effects if e not in mf.effects]
+    if surplus_effects:
+        loc_node = node.func if isinstance(node, ast.Call) else node
+        show_effects_allowed = mf.effects
+        if isinstance(mf.decl, ast.expr):
+            # We found the decorator that is the source of the effect constraint,
+            # which will contain the allowed effects as an explicit argument
+            show_effects_allowed = None
+        # Otherwise, the error message points at all decorators, which may or may not
+        # list the allowed effects, so list them explicitly
+
+        callee = loc_node.id if isinstance(loc_node, ast.Name) else func_ty
+        raise GuppyTypeError(
+            TooManyEffectsError(
+                loc_node, callee, surplus_effects, mf.decl_name
+            ).add_sub_diagnostic(
+                TooManyEffectsError.MaxFromDecl(mf.decl, show_effects_allowed)
+            )
+        )
+
+
 def synthesize_call(
     func_ty: FunctionType, args: list[ast.expr], node: AstNode, ctx: Context
 ) -> tuple[list[ast.expr], Type, Inst]:
@@ -1357,7 +1384,9 @@ def synthesize_call(
     inst = check_all_solved(subst, free_vars, func_ty, node)
 
     # Finally, check that the instantiation respects the linearity requirements
+    # and the effects allowed in the context.
     check_inst(func_ty, inst, node)
+    _check_effects(func_ty, ctx, node)
 
     return args, unquantified.output.substitute(subst), inst
 
@@ -1443,7 +1472,9 @@ def check_call(
     subst = {v: t for v, t in subst.items() if v in ty.unsolved_vars}
 
     # Finally, check that the instantiation respects the linearity requirements
+    # and the effects allowed in the context.
     check_inst(func_ty, inst, node)
+    _check_effects(func_ty, ctx, node)
 
     return inputs, subst, inst
 
@@ -1565,7 +1596,12 @@ def check_generator(
     # The rest is checked in a new nested context to ensure that variables don't escape
     # their scope
     inner_locals: Locals[str, Variable] = Locals({}, parent_scope=ctx.locals)
-    inner_ctx = Context(ctx.globals, inner_locals, ctx.generic_param_inst)
+    inner_ctx = Context(
+        ctx.globals,
+        inner_locals,
+        ctx.generic_param_inst,
+        ctx.max_effects_from,
+    )
     expr_sth, stmt_chk = ExprSynthesizer(inner_ctx), StmtChecker(inner_ctx)
     gen.iter, iter_ty = expr_sth.visit(gen.iter)
     gen.iter = with_type(iter_ty, gen.iter)

guppylang-internals/src/guppylang_internals/checker/func_checker.py

@@ -15,7 +15,13 @@
 from guppylang_internals.cfg.bb import BB
 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.core import (
+    Context,
+    EffectLimitDecl,
+    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
@@ -159,7 +165,16 @@ def check_global_func_def(
     generic_args = {
         param.name: arg for param, arg in zip(generic_ty.params, type_args, strict=True)
     }
-    return check_cfg(cfg, inputs, ty.output, generic_args, func_def.name, globals)
+    max_effects_from = EffectLimitDecl.for_def(ty, func_def)
+    return check_cfg(
+        cfg,
+        inputs,
+        ty.output,
+        generic_args,
+        func_def.name,
+        globals,
+        max_effects_from=max_effects_from,
+    )
 
 
 def check_nested_func_def(
@@ -168,7 +183,13 @@ def check_nested_func_def(
     ctx: Context,
 ) -> CheckedNestedFunctionDef:
     """Type checks a local (nested) function definition."""
-    func_ty = check_signature(func_def, ctx.globals)
+    # For now we assume the nested function has the same effects as that enclosing.
+    # We could do better by allowing a separate annotation (rather than a parameter
+    # to @guppy), but we will wait for callgraph analysis to compute precisely:
+    # nested functions are not part of any public API, so changes are not breaking.
+    func_ty = check_signature(func_def, ctx.globals).with_effects(
+        None if ctx.max_effects_from is None else ctx.max_effects_from.effects
+    )
     assert func_ty.input_names is not None
 
     if func_ty.parametrized:
@@ -247,7 +268,17 @@ def check_nested_func_def(
             # Otherwise, we treat it like a local name
             inputs.append(Variable(func_def.name, func_def.ty, func_def))
 
-    checked_cfg = check_cfg(cfg, inputs, func_ty.output, {}, func_def.name, globals)
+    checked_cfg = check_cfg(
+        cfg,
+        inputs,
+        func_ty.output,
+        {},
+        func_def.name,
+        globals,
+        # As comment above, assume nested func has same effects as enclosing
+        # (hence the decl giving the effects is that of the enclosing func too).
+        max_effects_from=ctx.max_effects_from,
+    )
     checked_def = CheckedNestedFunctionDef(
         def_id,
         checked_cfg,

guppylang-internals/src/guppylang_internals/checker/modifier_checker.py

@@ -5,7 +5,7 @@
 from guppylang_internals.ast_util import with_loc
 from guppylang_internals.cfg.bb import BB
 from guppylang_internals.checker.cfg_checker import check_cfg
-from guppylang_internals.checker.core import Context, Variable
+from guppylang_internals.checker.core import Context, EffectLimitDecl, Variable
 from guppylang_internals.checker.unitary_checker import check_invalid_under_dagger
 from guppylang_internals.definition.common import DefId
 from guppylang_internals.nodes import CheckedModifiedBlock, ModifiedBlock
@@ -19,7 +19,10 @@
 
 
 def check_modified_block(
-    modified_block: ModifiedBlock, bb: BB, ctx: Context
+    modified_block: ModifiedBlock,
+    bb: BB,
+    ctx: Context,
+    max_effects_from: EffectLimitDecl | None,
 ) -> CheckedModifiedBlock:
     """Type checks a modifier definition."""
     cfg = modified_block.cfg
@@ -53,6 +56,7 @@ def check_modified_block(
         {},
         "__modified__()",
         globals,
+        max_effects_from=max_effects_from,
         # We pass the first modifier node for better error messages in the cfg checker
         first_modifier_node=modified_block.first_modifier_node,
     )

guppylang-internals/src/guppylang_internals/checker/stmt_checker.py

@@ -417,7 +417,9 @@ def visit_ModifiedBlock(self, node: ModifiedBlock) -> ast.stmt:
             raise InternalGuppyError("BB required to check with block!")
 
         # check the body of the modified block
-        checked_modified_block = check_modified_block(node, self.bb, self.ctx)
+        checked_modified_block = check_modified_block(
+            node, self.bb, self.ctx, max_effects_from=self.ctx.max_effects_from
+        )
 
         # check the arguments of the control and power.
         for control in checked_modified_block.control: