Type error codes

ATTR_DEFINED = ErrorCode(
    "attr-defined",
    "Check that attribute exists",
    "General"
)

class Resource:
    def __init__(self, name: str) -> None:
        self.name = name

r = Resource('x')
print(r.name)  # OK
print(r.id)  # Error: "Resource" has no attribute "id"  [attr-defined]

UNION_ATTR = ErrorCode(
    "union-attr",
    "Check that attribute exists in each item of a union",
    "General"
)

class Cat:
    def meow(self) -> None: ...

class Dog:
    def bark(self) -> None: ...

def make_sound(animal: Cat | Dog) -> None:
    animal.meow()  # Error: Item "Dog" of "Cat | Dog" has no attribute "meow"  [union-attr]

CALL_ARG = ErrorCode(
    "call-arg",
    "Check number, names and kinds of arguments in calls",
    "General"
)

def greet(name: str) -> None:
    print('hello', name)

greet('jack')  # OK
greet('jill', 'jack')  # Error: Too many arguments for "greet"  [call-arg]
greet()  # Error: Missing positional argument "name"  [call-arg]

ARG_TYPE = ErrorCode(
    "arg-type",
    "Check argument types in calls",
    "General"
)

def add(x: int, y: int) -> int:
    return x + y

add(1, 2)  # OK
add(1, "2")  # Error: Argument 2 to "add" has incompatible type "str"; expected "int"  [arg-type]

CALL_OVERLOAD = ErrorCode(
    "call-overload",
    "Check that an overload variant matches arguments",
    "General"
)

from typing import overload

@overload
def process(x: int) -> str: ...
@overload
def process(x: str) -> int: ...
def process(x: int | str) -> int | str:
    return str(x) if isinstance(x, int) else int(x)

process(42)  # OK
process("hello")  # OK  
process(3.14)  # Error: No overload variant matches argument type "float"  [call-overload]

RETURN = ErrorCode(
    "return",
    "Check that function always returns a value",
    "General"
)

def get_value(x: int) -> int:
    if x > 0:
        return x
    # Error: Missing return statement  [return]

RETURN_VALUE = ErrorCode(
    "return-value",
    "Check that return value is compatible with signature",
    "General"
)

def get_name() -> str:
    return "Alice"  # OK

def get_age() -> int:
    return "25"  # Error: Incompatible return value type (got "str", expected "int")  [return-value]

ASSIGNMENT = ErrorCode(
    "assignment",
    "Check that assigned value is compatible with target",
    "General"
)

x: int = 42  # OK
y: str = "hello"  # OK
x = "world"  # Error: Incompatible types in assignment (expression has type "str", variable has type "int")  [assignment]

METHOD_ASSIGN = ErrorCode(
    "method-assign",
    "Check that assignment target is not a method",
    "General",
    sub_code_of=ASSIGNMENT,
)

class MyClass:
    def method(self) -> None: ...

MyClass.method = lambda self: None  # Error: Cannot assign to a method  [method-assign]

VALID_TYPE = ErrorCode(
    "valid-type",
    "Check that type (annotation) is valid",
    "General"
)

def log(x: object) -> None:
    print('log:', repr(x))

# Error: Function "log" is not valid as a type  [valid-type]
def process(f: log) -> None:
    f("hello")

# Correct:
from collections.abc import Callable
def process(f: Callable[[object], None]) -> None:
    f("hello")

TYPE_ARG = ErrorCode(
    "type-arg",
    "Check that generic type arguments are present",
    "General"
)

# Error: Missing type arguments for generic type "list"  [type-arg]
def process(items: list) -> None:
    ...

# Correct:
def process(items: list[int]) -> None:
    ...

TYPE_VAR = ErrorCode(
    "type-var",
    "Check that type variable values are valid",
    "General"
)

from typing import TypeVar

T = TypeVar('T', int, str)

def process(x: T) -> T:
    return x

process(42)  # OK
process("hello")  # OK
process(3.14)  # Error: Value of type variable "T" cannot be "float"  [type-var]

OPERATOR = ErrorCode(
    "operator",
    "Check that operator is valid for operands",
    "General"
)

x = 1 + 2  # OK
y = "hello" + " world"  # OK
z = 1 + "hello"  # Error: Unsupported operand types for + ("int" and "str")  [operator]

INDEX = ErrorCode(
    "index",
    "Check indexing operations",
    "General"
)

items = [1, 2, 3]
x = items[0]  # OK
y = items["key"]  # Error: Invalid index type "str" for "list[int]"; expected type "int"  [index]

LIST_ITEM = ErrorCode(
    "list-item",
    "Check list items in a list expression [item, ...]",
    "General"
)

items: list[int] = [1, 2, 3]  # OK
names: list[str] = ["a", "b", 3]  # Error: List item 2 has incompatible type "int"; expected "str"  [list-item]

DICT_ITEM = ErrorCode(
    "dict-item",
    "Check dict items in a dict expression {key: value, ...}",
    "General"
)

mapping: dict[str, int] = {"a": 1, "b": 2}  # OK
wrong: dict[str, int] = {"a": "wrong"}  # Error: Dict entry 0 has incompatible type "str": "str"; expected "str": "int"  [dict-item]

TYPEDDICT_ITEM = ErrorCode(
    "typeddict-item",
    "Check items when constructing TypedDict",
    "General"
)

from typing import TypedDict

class Person(TypedDict):
    name: str
    age: int

p: Person = {"name": "Alice", "age": 30}  # OK
wrong: Person = {"name": "Bob", "age": "thirty"}  # Error: Incompatible types (expression has type "str", TypedDict item "age" has type "int")  [typeddict-item]

TYPEDDICT_UNKNOWN_KEY = ErrorCode(
    "typeddict-unknown-key",
    "Check unknown keys when constructing TypedDict",
    "General",
    sub_code_of=TYPEDDICT_ITEM,
)

from typing import TypedDict

class Point(TypedDict):
    x: int
    y: int

p: Point = {"x": 1, "y": 2, "z": 3}  # Error: Extra key "z" for TypedDict "Point"  [typeddict-unknown-key]

OVERRIDE = ErrorCode(
    "override",
    "Check that method override is compatible with base class",
    "General"
)

class Base:
    def method(self, x: int) -> str:
        return str(x)

class Derived(Base):
    # Error: Argument 1 of "method" is incompatible with "Base"  [override]
    def method(self, x: str) -> str:
        return x

HAS_TYPE = ErrorCode(
    "has-type",
    "Check that type of reference can be determined",
    "General"
)

VAR_ANNOTATED = ErrorCode(
    "var-annotated",
    "Require variable annotation if type can't be inferred",
    "General"
)

class Container:
    def __init__(self) -> None:
        # Error: Need type annotation for "items"  [var-annotated]
        self.items = []
        
        # Correct:
        self.items: list[str] = []

FUNC_RETURNS_VALUE = ErrorCode(
    "func-returns-value",
    "Check that called function returns a value in value context",
    "General"
)

def log(msg: str) -> None:
    print(msg)

# Error: "log" does not return a value  [func-returns-value]
result = log("hello")

ABSTRACT = ErrorCode(
    "abstract",
    "Prevent instantiation of classes with abstract attributes",
    "General"
)

from abc import ABC, abstractmethod

class Base(ABC):
    @abstractmethod
    def method(self) -> None: ...

# Error: Cannot instantiate abstract class "Base" with abstract attribute "method"  [abstract]
obj = Base()

COMPARISON_OVERLAP = ErrorCode(
    "comparison-overlap",
    "Check that types in comparisons and 'in' expressions overlap",
    "General"
)

# mypy: strict-equality

x: int = 5
y: str = "5"

# Error: Non-overlapping equality check (left operand type: "int", right operand type: "str")  [comparison-overlap]
if x == y:
    pass

STRING_FORMATTING = ErrorCode(
    "str-format",
    "Check that string formatting/interpolation is type-safe",
    "General"
)

name = "Alice"
age = 30

f"{name} is {age} years old"  # OK
"{} and {}".format("spam")  # Error: Cannot find replacement for positional format specifier 1  [str-format]

"{:d}".format(3.14)  # Error: Incompatible types in string interpolation  [str-format]

STR_BYTES_PY3 = ErrorCode(
    "str-bytes-safe",
    "Warn about implicit coercions related to bytes and string types",
    "General"
)

b = b"hello"

# Error: If x = b'abc' then f"{x}" produces "b'abc'", not "abc"  [str-bytes-safe]
print(f"Message: {b}")

# Correct:
print(f"Message: {b.decode('utf-8')}")
print(f"Message: {b!r}")  # OK if you want "b'hello'"