guppylang-internals 0.21.0__py3-none-any.whl

guppylang_internals/checker/errors/linearity.py

@@ -0,0 +1,300 @@
+"""Collection of error messages emitted during linearity checking."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, ClassVar
+
+from guppylang_internals.diagnostic import Error, Help, Note
+
+if TYPE_CHECKING:
+    from guppylang_internals.checker.core import (
+        Place,
+        Variable,
+    )
+    from guppylang_internals.checker.linearity_checker import UseKind
+    from guppylang_internals.definition.struct import StructField
+    from guppylang_internals.tys.ty import (
+        StructType,
+        TupleType,
+        Type,
+    )
+
+
+@dataclass(frozen=True)
+class AlreadyUsedError(Error):
+    title: ClassVar[str] = "Copy violation"
+    span_label: ClassVar[str] = (
+        "{place.describe} with non-copyable type `{place.ty}` cannot be "
+        "{kind.subjunctive} ..."
+    )
+    place: Place
+    kind: UseKind
+
+    @dataclass(frozen=True)
+    class PrevUse(Note):
+        span_label: ClassVar[str] = "since it was already {prev_kind.subjunctive} here"
+        prev_kind: UseKind
+
+    @dataclass(frozen=True)
+    class MakeCopy(Help):
+        message: ClassVar[str] = (
+            "Consider copying `{place}` instead of moving it: `{place}.copy()`"
+        )
+
+
+@dataclass(frozen=True)
+class ComprAlreadyUsedError(Error):
+    title: ClassVar[str] = "Copy violation"
+    span_label: ClassVar[str] = (
+        "{place.describe} with non-copyable type `{place.ty}` would be "
+        "{kind.subjunctive} multiple times when evaluating this comprehension"
+    )
+    place: Place
+    kind: UseKind
+
+    @dataclass(frozen=True)
+    class PrevUse(Note):
+        span_label: ClassVar[str] = "since it was already {prev_kind.subjunctive} here"
+        prev_kind: UseKind
+
+
+@dataclass(frozen=True)
+class PlaceNotUsedError(Error):
+    title: ClassVar[str] = "Drop violation"
+    place: Place
+
+    @property
+    def rendered_span_label(self) -> str:
+        s = f"{self.place.describe} with non-droppable type `{self.place.ty}` "
+        match self.children:
+            case [PlaceNotUsedError.Branch(), *_]:
+                return s + "may be leaked ..."
+            case _:
+                return s + "is leaked"
+
+    @dataclass(frozen=True)
+    class Branch(Note):
+        span_label: ClassVar[str] = "if this expression is `{truth_value}`"
+        truth_value: bool
+
+    @dataclass(frozen=True)
+    class Fix(Help):
+        message: ClassVar[str] = (
+            "Make sure that `{place}` is consumed or returned to avoid the leak"
+        )
+
+
+@dataclass(frozen=True)
+class UnnamedExprNotUsedError(Error):
+    title: ClassVar[str] = "Drop violation"
+    span_label: ClassVar[str] = "Expression with non-droppable type `{ty}` is leaked"
+    ty: Type
+
+    @dataclass(frozen=True)
+    class Fix(Help):
+        message: ClassVar[str] = "Consider assigning this value to a local variable"
+
+
+@dataclass(frozen=True)
+class UnnamedFieldNotUsedError(Error):
+    title: ClassVar[str] = "Drop violation"
+    span_label: ClassVar[str] = (
+        "Non-droppable field `{field.name}` of expression with type `{struct_ty}` is "
+        "leaked"
+    )
+    field: StructField
+    struct_ty: StructType
+
+    @dataclass(frozen=True)
+    class Fix(Help):
+        message: ClassVar[str] = (
+            "Consider assigning this value to a local variable before accessing the "
+            "field `{used_field.name}`"
+        )
+        used_field: StructField
+
+
+@dataclass(frozen=True)
+class UnnamedSubscriptNotUsedError(Error):
+    title: ClassVar[str] = "Drop violation"
+    span_label: ClassVar[str] = (
+        "Non-droppable items of expression with type `{container_ty}` are leaked ..."
+    )
+    container_ty: Type
+
+    @dataclass(frozen=True)
+    class SubscriptHint(Note):
+        span_label: ClassVar[str] = "since only this subscript is used"
+
+    @dataclass(frozen=True)
+    class Fix(Help):
+        message: ClassVar[str] = (
+            "Consider assigning this value to a local variable before subscripting it"
+        )
+
+
+@dataclass(frozen=True)
+class UnnamedTupleNotUsedError(Error):
+    title: ClassVar[str] = "Drop violation"
+    span_label: ClassVar[str] = (
+        "Non-droppable items inside expression of type `{tuple_ty}` are leaked"
+    )
+    tuple_ty: TupleType
+
+    @dataclass(frozen=True)
+    class Fix(Help):
+        message: ClassVar[str] = (
+            "Consider assigning this value to a local variable before subscripting it"
+        )
+
+
+@dataclass(frozen=True)
+class NotOwnedError(Error):
+    title: ClassVar[str] = "Not owned"
+    place: Place
+    kind: UseKind
+    is_call_arg: bool
+    func_name: str | None
+    calling_func_name: str
+
+    @property
+    def rendered_span_label(self) -> str:
+        if self.is_call_arg:
+            f = f"Function `{self.func_name}`" if self.func_name else "Function"
+            return (
+                f"{f} wants to take ownership of this argument, but "
+                f"`{self.calling_func_name}` doesn't own `{self.place}`"
+            )
+        return (
+            f"Cannot {self.kind.indicative} `{self.place}` since "
+            f"`{self.calling_func_name}` doesn't own it"
+        )
+
+    @dataclass(frozen=True)
+    class MakeOwned(Help):
+        span_label: ClassVar[str] = (
+            "Argument `{place.root.name}` is only borrowed. Consider taking ownership: "
+            "`{place.root.name}: {place.root.ty} @owned`"
+        )
+
+    @dataclass(frozen=True)
+    class MakeCopy(Help):
+        span_label: ClassVar[str] = (
+            "Or consider copying this argument: `{place}.copy()`"
+        )
+
+
+@dataclass(frozen=True)
+class MoveOutOfSubscriptError(Error):
+    title: ClassVar[str] = "Subscript {kind.subjunctive}"
+    span_label: ClassVar[str] = (
+        "Cannot {kind.indicative} a subscript of `{parent}` with non-copyable type "
+        "`{parent.ty}`"
+    )
+    kind: UseKind
+    parent: Place
+
+    @dataclass(frozen=True)
+    class Explanation(Note):
+        message: ClassVar[str] = (
+            "Subscripts on non-copyable types are only allowed to be borrowed, not "
+            "{kind.subjunctive}"
+        )
+
+
+@dataclass(frozen=True)
+class BorrowShadowedError(Error):
+    title: ClassVar[str] = "Borrow shadowed"
+    span_label: ClassVar[str] = "Assignment shadows borrowed argument `{place}`"
+    place: Place
+
+    @dataclass(frozen=True)
+    class Rename(Help):
+        message: ClassVar[str] = "Consider assigning to a different name"
+
+
+@dataclass(frozen=True)
+class BorrowSubPlaceUsedError(Error):
+    title: ClassVar[str] = "Copy violation"
+    span_label: ClassVar[str] = (
+        "Borrowed argument {borrowed_var} cannot be returned to the caller ..."
+    )
+    borrowed_var: Variable
+    sub_place: Place
+
+    @dataclass(frozen=True)
+    class PrevUse(Note):
+        span_label: ClassVar[str] = (
+            "since `{sub_place}` with non-copyable type `{sub_place.ty}` was already "
+            "{kind.subjunctive} here"
+        )
+        kind: UseKind
+
+    @dataclass(frozen=True)
+    class Fix(Help):
+        message: ClassVar[str] = (
+            "Consider writing a value back into `{sub_place}` before returning"
+        )
+
+
+@dataclass(frozen=True)
+class DropAfterCallError(Error):
+    title: ClassVar[str] = "Drop violation"
+    span_label: ClassVar[str] = (
+        "Value with non-droppable type `{ty}` would be leaked after {func} returns"
+    )
+    ty: Type
+    func_name: str | None
+
+    @property
+    def func(self) -> str:
+        return f"`{self.func_name}`" if self.func_name else "the function"
+
+    @dataclass(frozen=True)
+    class Assign(Help):
+        message: ClassVar[str] = (
+            "Consider assigning the value to a local variable before passing it to "
+            "{func}"
+        )
+
+
+@dataclass(frozen=True)
+class NonCopyableCaptureError(Error):
+    title: ClassVar[str] = "Copy violation"
+    span_label: ClassVar[str] = (
+        "{var.describe} with non-copyable type {var.ty} cannot be used here since "
+        "`{var}` is captured from an outer scope"
+    )
+    var: Variable
+
+    @dataclass(frozen=True)
+    class DefinedHere(Note):
+        span_label: ClassVar[str] = "`{var}` defined here"
+
+
+@dataclass(frozen=True)
+class NonCopyablePartialApplyError(Error):
+    title: ClassVar[str] = "Copy violation"
+    span_label: ClassVar[str] = (
+        "This expression implicitly constructs a closure that captures a non-copyable "
+        "value"
+    )
+
+    @dataclass(frozen=True)
+    class Captured(Note):
+        span_label: ClassVar[str] = (
+            "This expression with non-copyable type `{ty}` is implicitly captured"
+        )
+        ty: Type
+
+
+@dataclass(frozen=True)
+class NonDroppableForBreakError(Error):
+    title: ClassVar[str] = "Break in non-droppable loop"
+    span_label: ClassVar[str] = "Early exit in non-droppable loops is not allowed"
+
+    @dataclass(frozen=True)
+    class NonDroppableIteratorType(Note):
+        span_label: ClassVar[str] = "Iterator has non-droppable type `{ty}`"
+        ty: Type

guppylang_internals/checker/errors/type_errors.py

@@ -0,0 +1,344 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, ClassVar
+
+from guppylang_internals.diagnostic import Error, Help, Note
+
+if TYPE_CHECKING:
+    from guppylang_internals.definition.struct import StructField
+    from guppylang_internals.tys.const import Const
+    from guppylang_internals.tys.param import TypeParam
+    from guppylang_internals.tys.ty import FunctionType, Type
+
+
+@dataclass(frozen=True)
+class TypeMismatchError(Error):
+    title: ClassVar[str] = "Type mismatch"
+    span_label: ClassVar[str] = "Expected {kind} of type `{expected}`, got `{actual}`"
+
+    expected: Type
+    actual: Type
+    kind: str = "expression"
+
+    @dataclass(frozen=True)
+    class CantInferParam(Note):
+        message: ClassVar[str] = (
+            "Couldn't infer an instantiation for type variable `?{type_var}` "
+            "(higher-rank polymorphic types are not supported)"
+        )
+        type_var: str
+
+    @dataclass(frozen=True)
+    class CantInstantiateFreeVars(Note):
+        message: ClassVar[str] = (
+            "Can't instantiate parameter `{param}` with type `{illegal_inst}` "
+            "containing free variables"
+        )
+        param: str
+        illegal_inst: Type | Const
+
+
+@dataclass(frozen=True)
+class ConstMismatchError(Error):
+    title: ClassVar[str] = "Value mismatch"
+    span_label: ClassVar[str] = "Expected constant `{expected}`, got `{actual}`"
+
+    expected: Const
+    actual: Const
+
+
+@dataclass(frozen=True)
+class AssignFieldTypeMismatchError(Error):
+    title: ClassVar[str] = "Type mismatch"
+    span_label: ClassVar[str] = (
+        "Cannot assign expression of type `{actual}` to field `{field.name}` of type "
+        "`{field.ty}`"
+    )
+    actual: Type
+    field: StructField
+
+
+@dataclass(frozen=True)
+class AssignSubscriptTypeMismatchError(Error):
+    title: ClassVar[str] = "Type mismatch"
+    span_label: ClassVar[str] = (
+        "Cannot assign expression of type `{actual}` to array element of type "
+        "`{expected}`"
+    )
+    actual: Type
+    expected: Type
+
+
+@dataclass(frozen=True)
+class NonLinearInstantiateError(Error):
+    title: ClassVar[str] = "Not defined for linear argument"
+    span_label: ClassVar[str] = (
+        "Cannot instantiate {expected} type parameter `{param.name}` in type "
+        "`{func_ty}` with non-{expected} type `{ty}`"
+    )
+    param: TypeParam
+    func_ty: FunctionType
+    ty: Type
+
+    @property
+    def expected(self) -> str:
+        return "copyable" if self.param.must_be_copyable else "droppable"
+
+
+@dataclass(frozen=True)
+class TypeInferenceError(Error):
+    title: ClassVar[str] = "Cannot infer type"
+    span_label: ClassVar[str] = (
+        "Cannot infer type variables in expression of type `{unsolved_ty}`"
+    )
+    unsolved_ty: Type
+
+
+@dataclass(frozen=True)
+class IllegalConstant(Error):
+    title: ClassVar[str] = "Unsupported constant"
+    span_label: ClassVar[str] = "Type `{python_ty.__name__}` is not supported"
+    python_ty: type
+
+
+@dataclass(frozen=True)
+class ModuleMemberNotFoundError(Error):
+    title: ClassVar[str] = "Not found in module"
+    span_label: ClassVar[str] = "Module `{module_name}` has no member `{member}`"
+    module_name: str
+    member: str
+
+
+@dataclass(frozen=True)
+class AttributeNotFoundError(Error):
+    title: ClassVar[str] = "Attribute not found"
+    span_label: ClassVar[str] = "`{ty}` has no attribute `{attribute}`"
+    ty: Type
+    attribute: str
+
+
+@dataclass(frozen=True)
+class UnaryOperatorNotDefinedError(Error):
+    title: ClassVar[str] = "Operator not defined"
+    span_label: ClassVar[str] = "Unary operator `{op}` not defined for `{ty}`"
+    ty: Type
+    op: str
+
+
+@dataclass(frozen=True)
+class BinaryOperatorNotDefinedError(Error):
+    title: ClassVar[str] = "Operator not defined"
+    span_label: ClassVar[str] = (
+        "Binary operator `{op}` not defined for `{left_ty}` and `{right_ty}`"
+    )
+    left_ty: Type
+    right_ty: Type
+    op: str
+
+
+@dataclass(frozen=True)
+class BadProtocolError(Error):
+    title: ClassVar[str] = "Not {is_not}"
+    span_label: ClassVar[str] = "Expression of type `{ty}` is not {is_not}"
+    ty: Type
+    is_not: str
+
+    @dataclass(frozen=True)
+    class MethodMissing(Help):
+        message: ClassVar[str] = "Implement missing method: `{method}: {signature}`"
+        method: str
+        signature: FunctionType
+
+    @dataclass(frozen=True)
+    class BadSignature(Help):
+        message: ClassVar[str] = (
+            "Fix signature of method `{ty}.{method}`:  Expected `{exp_signature}`, got "
+            "`{act_signature}`"
+        )
+        ty: Type
+        method: str
+        exp_signature: FunctionType
+        act_signature: FunctionType
+
+
+@dataclass(frozen=True)
+class MissingReturnValueError(Error):
+    title: ClassVar[str] = "Missing return value"
+    span_label: ClassVar[str] = "Expected return value of type `{ty}`"
+    ty: Type
+
+
+@dataclass(frozen=True)
+class TypeApplyNotGenericError(Error):
+    title: ClassVar[str] = "Not generic"
+    span_label: ClassVar[str] = (
+        "{thing} is not generic, so no type parameters can be provided"
+    )
+    func_name: str | None
+
+    @property
+    def thing(self) -> str:
+        return f"`{self.func_name}`" if self.func_name else "This function"
+
+
+@dataclass(frozen=True)
+class NotCallableError(Error):
+    title: ClassVar[str] = "Not callable"
+    span_label: ClassVar[str] = "Expected a function, got expression of type `{actual}`"
+    actual: Type
+
+
+@dataclass(frozen=True)
+class WrongNumberOfArgsError(Error):
+    title: ClassVar[str] = ""  # Custom implementation in `rendered_title`
+    expected: int
+    actual: int
+    detailed: bool = True
+    is_type_apply: bool = False
+
+    @property
+    def rendered_title(self) -> str:
+        return (
+            f"Not enough {self.argument_kind}s"
+            if self.expected > self.actual
+            else f"Too many {self.argument_kind}s"
+        )
+
+    @property
+    def argument_kind(self) -> str:
+        return "type argument" if self.is_type_apply else "argument"
+
+    @property
+    def rendered_span_label(self) -> str:
+        if not self.detailed:
+            return f"Expected {self.expected}, got {self.actual}"
+        diff = self.expected - self.actual
+        if diff < 0:
+            msg = f"Unexpected {self.argument_kind}"
+            if diff < -1:
+                msg += "s"
+        else:
+            msg = f"Missing {self.argument_kind}"
+            if diff > 1:
+                msg += "s"
+        return f"{msg} (expected {self.expected}, got {self.actual})"
+
+    @dataclass(frozen=True)
+    class SignatureHint(Note):
+        message: ClassVar[str] = "Function signature is `{sig}`"
+        sig: FunctionType
+
+
+@dataclass(frozen=True)
+class WrongNumberOfUnpacksError(Error):
+    title: ClassVar[str] = "{prefix} values to unpack"
+    expected: int
+    actual: int
+    at_least: bool
+
+    @property
+    def prefix(self) -> str:
+        return "Not enough" if self.expected > self.actual else "Too many"
+
+    @property
+    def rendered_span_label(self) -> str:
+        diff = self.expected - self.actual
+        if diff < 0:
+            msg = "Unexpected assignment " + ("targets" if diff < -1 else "target")
+            at_least = "at least " if self.at_least else ""
+        else:
+            msg = "Not enough assignment targets"
+            assert not self.at_least
+            at_least = ""
+        return f"{msg} (expected {self.expected}, got {at_least}{self.actual})"
+
+
+@dataclass(frozen=True)
+class UnpackableError(Error):
+    title: ClassVar[str] = "Unpackable"
+    span_label: ClassVar[str] = "Expression of type `{ty}` cannot be unpacked"
+    ty: Type
+
+    @dataclass(frozen=True)
+    class NonStaticIter(Note):
+        message: ClassVar[str] = (
+            "Unpacking of iterable types like `{ty}` is only allowed if the number of "
+            "items yielded by the iterator is statically known. This is not the case "
+            "for `{ty}`."
+        )
+
+    @dataclass(frozen=True)
+    class GenericSize(Note):
+        message: ClassVar[str] = (
+            "Unpacking of iterable types like `{ty}` is only allowed if the number of "
+            "items yielded by the iterator is statically known. Here, the number of "
+            "items `{num}` is generic and can change between different function "
+            "invocations."
+        )
+        num: Const
+
+
+@dataclass(frozen=True)
+class StarredTupleUnpackError(Error):
+    title: ClassVar[str] = "Invalid starred unpacking"
+    span_label: ClassVar[str] = (
+        "Expression of type `{ty}` cannot be collected into a starred assignment since "
+        "the yielded items have different types"
+    )
+    ty: Type
+
+
+@dataclass(frozen=True)
+class AssignNonPlaceHelp(Help):
+    message: ClassVar[str] = (
+        "Consider assigning this value to a local variable first before assigning the "
+        "field `{field.name}`"
+    )
+    field: StructField
+
+
+@dataclass(frozen=True)
+class ArrayComprUnknownSizeError(Error):
+    title: ClassVar[str] = "Array comprehension with nonstatic size"
+    span_label: ClassVar[str] = "Cannot infer the size of this array comprehension ..."
+
+    @dataclass(frozen=True)
+    class IfGuard(Note):
+        span_label: ClassVar[str] = "since it depends on this condition"
+
+    @dataclass(frozen=True)
+    class DynamicIterator(Note):
+        span_label: ClassVar[str] = (
+            "since the number of elements yielded by this iterator is not statically "
+            "known"
+        )
+
+
+@dataclass(frozen=True)
+class TupleIndexOutOfBoundsError(Error):
+    title: ClassVar[str] = "Tuple index out of bounds"
+    span_label: ClassVar[str] = (
+        "Tuple index `{index}` is out of bounds for tuple of size `{size}`"
+    )
+    index: int
+    size: int
+
+
+@dataclass(frozen=True)
+class IntOverflowError(Error):
+    title: ClassVar[str] = "Integer {over_under}flow"
+    span_label: ClassVar[str] = (
+        "Value does not fit into a {bits}-bit {signed_unsigned} integer"
+    )
+    signed: bool
+    bits: int
+    is_underflow: bool
+
+    @property
+    def over_under(self) -> str:
+        return "under" if self.is_underflow else "over"
+
+    @property
+    def signed_unsigned(self) -> str:
+        return "signed" if self.signed else "unsigned"

guppylang_internals/checker/errors/wasm.py

@@ -0,0 +1,34 @@
+from dataclasses import dataclass
+from typing import ClassVar
+
+from guppylang_internals.diagnostic import Error
+from guppylang_internals.tys.ty import Type
+
+
+@dataclass(frozen=True)
+class WasmError(Error):
+    title: ClassVar[str] = "WASM signature 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"
+    )
+    ty: Type
+
+
+@dataclass(frozen=True)
+class UnWasmableType(WasmError):
+    span_label: ClassVar[str] = (
+        "WASM function signature contained an unsupported type: `{ty}`"
+    )
+    ty: Type
+
+
+@dataclass(frozen=True)
+class WasmTypeConversionError(Error):
+    title: ClassVar[str] = "Can't convert type to WASM"
+    span_label: ClassVar[str] = "`{thing}` cannot be converted to WASM"
+    ty: Type