mypy-dev 1.9.0.dev0__py3-none-any.whl

mypy/dmypy_util.py

@@ -0,0 +1,117 @@
+"""Shared code between dmypy.py and dmypy_server.py.
+
+This should be pretty lightweight and not depend on other mypy code (other than ipc).
+"""
+
+from __future__ import annotations
+
+import io
+import json
+from types import TracebackType
+from typing import Any, Final, Iterable, Iterator, TextIO
+
+from mypy.ipc import IPCBase
+
+DEFAULT_STATUS_FILE: Final = ".dmypy.json"
+
+
+def receive(connection: IPCBase) -> Any:
+    """Receive single JSON data frame from a connection.
+
+    Raise OSError if the data received is not valid JSON or if it is
+    not a dict.
+    """
+    bdata = connection.read()
+    if not bdata:
+        raise OSError("No data received")
+    try:
+        data = json.loads(bdata)
+    except Exception as e:
+        raise OSError("Data received is not valid JSON") from e
+    if not isinstance(data, dict):
+        raise OSError(f"Data received is not a dict ({type(data)})")
+    return data
+
+
+def send(connection: IPCBase, data: Any) -> None:
+    """Send data to a connection encoded and framed.
+
+    The data must be JSON-serializable. We assume that a single send call is a
+    single frame to be sent on the connect.
+    """
+    connection.write(json.dumps(data))
+
+
+class WriteToConn(TextIO):
+    """Helper class to write to a connection instead of standard output."""
+
+    def __init__(self, server: IPCBase, output_key: str, isatty: bool) -> None:
+        self.server = server
+        self.output_key = output_key
+        self._isatty = isatty
+
+    def __enter__(self) -> TextIO:
+        return self
+
+    def __exit__(
+        self,
+        t: type[BaseException] | None,
+        value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        pass
+
+    def __iter__(self) -> Iterator[str]:
+        raise io.UnsupportedOperation
+
+    def __next__(self) -> str:
+        raise io.UnsupportedOperation
+
+    def close(self) -> None:
+        pass
+
+    def fileno(self) -> int:
+        raise OSError
+
+    def flush(self) -> None:
+        pass
+
+    def isatty(self) -> bool:
+        return self._isatty
+
+    def read(self, n: int = 0) -> str:
+        raise io.UnsupportedOperation
+
+    def readable(self) -> bool:
+        return False
+
+    def readline(self, limit: int = 0) -> str:
+        raise io.UnsupportedOperation
+
+    def readlines(self, hint: int = 0) -> list[str]:
+        raise io.UnsupportedOperation
+
+    def seek(self, offset: int, whence: int = 0) -> int:
+        raise io.UnsupportedOperation
+
+    def seekable(self) -> bool:
+        return False
+
+    def tell(self) -> int:
+        raise io.UnsupportedOperation
+
+    def truncate(self, size: int | None = 0) -> int:
+        raise io.UnsupportedOperation
+
+    def write(self, output: str) -> int:
+        resp: dict[str, Any] = {}
+        resp[self.output_key] = output
+        send(self.server, resp)
+        return len(output)
+
+    def writable(self) -> bool:
+        return True
+
+    def writelines(self, lines: Iterable[str]) -> None:
+        for s in lines:
+            self.write(s)

mypy/erasetype.py

@@ -0,0 +1,278 @@
+from __future__ import annotations
+
+from typing import Callable, Container, cast
+
+from mypy.nodes import ARG_STAR, ARG_STAR2
+from mypy.types import (
+    AnyType,
+    CallableType,
+    DeletedType,
+    ErasedType,
+    Instance,
+    LiteralType,
+    NoneType,
+    Overloaded,
+    Parameters,
+    ParamSpecType,
+    PartialType,
+    ProperType,
+    TupleType,
+    Type,
+    TypeAliasType,
+    TypedDictType,
+    TypeOfAny,
+    TypeTranslator,
+    TypeType,
+    TypeVarId,
+    TypeVarTupleType,
+    TypeVarType,
+    TypeVisitor,
+    UnboundType,
+    UninhabitedType,
+    UnionType,
+    UnpackType,
+    get_proper_type,
+    get_proper_types,
+)
+
+
+def erase_type(typ: Type) -> ProperType:
+    """Erase any type variables from a type.
+
+    Also replace tuple types with the corresponding concrete types.
+
+    Examples:
+      A -> A
+      B[X] -> B[Any]
+      Tuple[A, B] -> tuple
+      Callable[[A1, A2, ...], R] -> Callable[..., Any]
+      Type[X] -> Type[Any]
+    """
+    typ = get_proper_type(typ)
+    return typ.accept(EraseTypeVisitor())
+
+
+class EraseTypeVisitor(TypeVisitor[ProperType]):
+    def visit_unbound_type(self, t: UnboundType) -> ProperType:
+        # TODO: replace with an assert after UnboundType can't leak from semantic analysis.
+        return AnyType(TypeOfAny.from_error)
+
+    def visit_any(self, t: AnyType) -> ProperType:
+        return t
+
+    def visit_none_type(self, t: NoneType) -> ProperType:
+        return t
+
+    def visit_uninhabited_type(self, t: UninhabitedType) -> ProperType:
+        return t
+
+    def visit_erased_type(self, t: ErasedType) -> ProperType:
+        return t
+
+    def visit_partial_type(self, t: PartialType) -> ProperType:
+        # Should not get here.
+        raise RuntimeError("Cannot erase partial types")
+
+    def visit_deleted_type(self, t: DeletedType) -> ProperType:
+        return t
+
+    def visit_instance(self, t: Instance) -> ProperType:
+        args: list[Type] = []
+        for tv in t.type.defn.type_vars:
+            # Valid erasure for *Ts is *tuple[Any, ...], not just Any.
+            if isinstance(tv, TypeVarTupleType):
+                args.append(
+                    UnpackType(
+                        tv.tuple_fallback.copy_modified(args=[AnyType(TypeOfAny.special_form)])
+                    )
+                )
+            else:
+                args.append(AnyType(TypeOfAny.special_form))
+        return Instance(t.type, args, t.line)
+
+    def visit_type_var(self, t: TypeVarType) -> ProperType:
+        return AnyType(TypeOfAny.special_form)
+
+    def visit_param_spec(self, t: ParamSpecType) -> ProperType:
+        return AnyType(TypeOfAny.special_form)
+
+    def visit_parameters(self, t: Parameters) -> ProperType:
+        raise RuntimeError("Parameters should have been bound to a class")
+
+    def visit_type_var_tuple(self, t: TypeVarTupleType) -> ProperType:
+        # Likely, we can never get here because of aggressive erasure of types that
+        # can contain this, but better still return a valid replacement.
+        return t.tuple_fallback.copy_modified(args=[AnyType(TypeOfAny.special_form)])
+
+    def visit_unpack_type(self, t: UnpackType) -> ProperType:
+        return AnyType(TypeOfAny.special_form)
+
+    def visit_callable_type(self, t: CallableType) -> ProperType:
+        # We must preserve the fallback type for overload resolution to work.
+        any_type = AnyType(TypeOfAny.special_form)
+        return CallableType(
+            arg_types=[any_type, any_type],
+            arg_kinds=[ARG_STAR, ARG_STAR2],
+            arg_names=[None, None],
+            ret_type=any_type,
+            fallback=t.fallback,
+            is_ellipsis_args=True,
+            implicit=True,
+        )
+
+    def visit_overloaded(self, t: Overloaded) -> ProperType:
+        return t.fallback.accept(self)
+
+    def visit_tuple_type(self, t: TupleType) -> ProperType:
+        return t.partial_fallback.accept(self)
+
+    def visit_typeddict_type(self, t: TypedDictType) -> ProperType:
+        return t.fallback.accept(self)
+
+    def visit_literal_type(self, t: LiteralType) -> ProperType:
+        # The fallback for literal types should always be either
+        # something like int or str, or an enum class -- types that
+        # don't contain any TypeVars. So there's no need to visit it.
+        return t
+
+    def visit_union_type(self, t: UnionType) -> ProperType:
+        erased_items = [erase_type(item) for item in t.items]
+        from mypy.typeops import make_simplified_union
+
+        return make_simplified_union(erased_items)
+
+    def visit_type_type(self, t: TypeType) -> ProperType:
+        return TypeType.make_normalized(t.item.accept(self), line=t.line)
+
+    def visit_type_alias_type(self, t: TypeAliasType) -> ProperType:
+        raise RuntimeError("Type aliases should be expanded before accepting this visitor")
+
+
+def erase_typevars(t: Type, ids_to_erase: Container[TypeVarId] | None = None) -> Type:
+    """Replace all type variables in a type with any,
+    or just the ones in the provided collection.
+    """
+
+    def erase_id(id: TypeVarId) -> bool:
+        if ids_to_erase is None:
+            return True
+        return id in ids_to_erase
+
+    return t.accept(TypeVarEraser(erase_id, AnyType(TypeOfAny.special_form)))
+
+
+def replace_meta_vars(t: Type, target_type: Type) -> Type:
+    """Replace unification variables in a type with the target type."""
+    return t.accept(TypeVarEraser(lambda id: id.is_meta_var(), target_type))
+
+
+class TypeVarEraser(TypeTranslator):
+    """Implementation of type erasure"""
+
+    def __init__(self, erase_id: Callable[[TypeVarId], bool], replacement: Type) -> None:
+        self.erase_id = erase_id
+        self.replacement = replacement
+
+    def visit_type_var(self, t: TypeVarType) -> Type:
+        if self.erase_id(t.id):
+            return self.replacement
+        return t
+
+    # TODO: below two methods duplicate some logic with expand_type().
+    # In fact, we may want to refactor this whole visitor to use expand_type().
+    def visit_instance(self, t: Instance) -> Type:
+        result = super().visit_instance(t)
+        assert isinstance(result, ProperType) and isinstance(result, Instance)
+        if t.type.fullname == "builtins.tuple":
+            # Normalize Tuple[*Tuple[X, ...], ...] -> Tuple[X, ...]
+            arg = result.args[0]
+            if isinstance(arg, UnpackType):
+                unpacked = get_proper_type(arg.type)
+                if isinstance(unpacked, Instance):
+                    assert unpacked.type.fullname == "builtins.tuple"
+                    return unpacked
+        return result
+
+    def visit_tuple_type(self, t: TupleType) -> Type:
+        result = super().visit_tuple_type(t)
+        assert isinstance(result, ProperType) and isinstance(result, TupleType)
+        if len(result.items) == 1:
+            # Normalize Tuple[*Tuple[X, ...]] -> Tuple[X, ...]
+            item = result.items[0]
+            if isinstance(item, UnpackType):
+                unpacked = get_proper_type(item.type)
+                if isinstance(unpacked, Instance):
+                    assert unpacked.type.fullname == "builtins.tuple"
+                    if result.partial_fallback.type.fullname != "builtins.tuple":
+                        # If it is a subtype (like named tuple) we need to preserve it,
+                        # this essentially mimics the logic in tuple_fallback().
+                        return result.partial_fallback.accept(self)
+                    return unpacked
+        return result
+
+    def visit_type_var_tuple(self, t: TypeVarTupleType) -> Type:
+        if self.erase_id(t.id):
+            return t.tuple_fallback.copy_modified(args=[self.replacement])
+        return t
+
+    def visit_param_spec(self, t: ParamSpecType) -> Type:
+        if self.erase_id(t.id):
+            return self.replacement
+        return t
+
+    def visit_type_alias_type(self, t: TypeAliasType) -> Type:
+        # Type alias target can't contain bound type variables (not bound by the type
+        # alias itself), so it is safe to just erase the arguments.
+        return t.copy_modified(args=[a.accept(self) for a in t.args])
+
+
+def remove_instance_last_known_values(t: Type) -> Type:
+    return t.accept(LastKnownValueEraser())
+
+
+class LastKnownValueEraser(TypeTranslator):
+    """Removes the Literal[...] type that may be associated with any
+    Instance types."""
+
+    def visit_instance(self, t: Instance) -> Type:
+        if not t.last_known_value and not t.args:
+            return t
+        return t.copy_modified(args=[a.accept(self) for a in t.args], last_known_value=None)
+
+    def visit_type_alias_type(self, t: TypeAliasType) -> Type:
+        # Type aliases can't contain literal values, because they are
+        # always constructed as explicit types.
+        return t
+
+    def visit_union_type(self, t: UnionType) -> Type:
+        new = cast(UnionType, super().visit_union_type(t))
+        # Erasure can result in many duplicate items; merge them.
+        # Call make_simplified_union only on lists of instance types
+        # that all have the same fullname, to avoid simplifying too
+        # much.
+        instances = [item for item in new.items if isinstance(get_proper_type(item), Instance)]
+        # Avoid merge in simple cases such as optional types.
+        if len(instances) > 1:
+            instances_by_name: dict[str, list[Instance]] = {}
+            p_new_items = get_proper_types(new.items)
+            for p_item in p_new_items:
+                if isinstance(p_item, Instance) and not p_item.args:
+                    instances_by_name.setdefault(p_item.type.fullname, []).append(p_item)
+            merged: list[Type] = []
+            for item in new.items:
+                orig_item = item
+                item = get_proper_type(item)
+                if isinstance(item, Instance) and not item.args:
+                    types = instances_by_name.get(item.type.fullname)
+                    if types is not None:
+                        if len(types) == 1:
+                            merged.append(item)
+                        else:
+                            from mypy.typeops import make_simplified_union
+
+                            merged.append(make_simplified_union(types))
+                            del instances_by_name[item.type.fullname]
+                else:
+                    merged.append(orig_item)
+            return UnionType.make_union(merged)
+        return new

mypy/errorcodes.py

@@ -0,0 +1,285 @@
+"""Classification of possible errors mypy can detect.
+
+These can be used for filtering specific errors.
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Final
+
+from mypy_extensions import mypyc_attr
+
+error_codes: dict[str, ErrorCode] = {}
+sub_code_map: dict[str, set[str]] = defaultdict(set)
+
+
+@mypyc_attr(allow_interpreted_subclasses=True)
+class ErrorCode:
+    def __init__(
+        self,
+        code: str,
+        description: str,
+        category: str,
+        default_enabled: bool = True,
+        sub_code_of: ErrorCode | None = None,
+    ) -> None:
+        self.code = code
+        self.description = description
+        self.category = category
+        self.default_enabled = default_enabled
+        self.sub_code_of = sub_code_of
+        if sub_code_of is not None:
+            assert sub_code_of.sub_code_of is None, "Nested subcategories are not supported"
+            sub_code_map[sub_code_of.code].add(code)
+        error_codes[code] = self
+
+    def __str__(self) -> str:
+        return f"<ErrorCode {self.code}>"
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ErrorCode):
+            return False
+        return self.code == other.code
+
+    def __hash__(self) -> int:
+        return hash((self.code,))
+
+
+ATTR_DEFINED: Final = ErrorCode("attr-defined", "Check that attribute exists", "General")
+NAME_DEFINED: Final = ErrorCode("name-defined", "Check that name is defined", "General")
+CALL_ARG: Final[ErrorCode] = ErrorCode(
+    "call-arg", "Check number, names and kinds of arguments in calls", "General"
+)
+ARG_TYPE: Final = ErrorCode("arg-type", "Check argument types in calls", "General")
+CALL_OVERLOAD: Final = ErrorCode(
+    "call-overload", "Check that an overload variant matches arguments", "General"
+)
+VALID_TYPE: Final[ErrorCode] = ErrorCode(
+    "valid-type", "Check that type (annotation) is valid", "General"
+)
+VAR_ANNOTATED: Final = ErrorCode(
+    "var-annotated", "Require variable annotation if type can't be inferred", "General"
+)
+OVERRIDE: Final = ErrorCode(
+    "override", "Check that method override is compatible with base class", "General"
+)
+RETURN: Final[ErrorCode] = ErrorCode(
+    "return", "Check that function always returns a value", "General"
+)
+RETURN_VALUE: Final[ErrorCode] = ErrorCode(
+    "return-value", "Check that return value is compatible with signature", "General"
+)
+ASSIGNMENT: Final[ErrorCode] = ErrorCode(
+    "assignment", "Check that assigned value is compatible with target", "General"
+)
+METHOD_ASSIGN: Final[ErrorCode] = ErrorCode(
+    "method-assign",
+    "Check that assignment target is not a method",
+    "General",
+    sub_code_of=ASSIGNMENT,
+)
+TYPE_ARG: Final = ErrorCode("type-arg", "Check that generic type arguments are present", "General")
+TYPE_VAR: Final = ErrorCode("type-var", "Check that type variable values are valid", "General")
+UNION_ATTR: Final = ErrorCode(
+    "union-attr", "Check that attribute exists in each item of a union", "General"
+)
+INDEX: Final = ErrorCode("index", "Check indexing operations", "General")
+OPERATOR: Final = ErrorCode("operator", "Check that operator is valid for operands", "General")
+LIST_ITEM: Final = ErrorCode(
+    "list-item", "Check list items in a list expression [item, ...]", "General"
+)
+DICT_ITEM: Final = ErrorCode(
+    "dict-item", "Check dict items in a dict expression {key: value, ...}", "General"
+)
+TYPEDDICT_ITEM: Final = ErrorCode(
+    "typeddict-item", "Check items when constructing TypedDict", "General"
+)
+TYPEDDICT_UNKNOWN_KEY: Final = ErrorCode(
+    "typeddict-unknown-key",
+    "Check unknown keys when constructing TypedDict",
+    "General",
+    sub_code_of=TYPEDDICT_ITEM,
+)
+HAS_TYPE: Final = ErrorCode(
+    "has-type", "Check that type of reference can be determined", "General"
+)
+IMPORT: Final = ErrorCode(
+    "import", "Require that imported module can be found or has stubs", "General"
+)
+IMPORT_NOT_FOUND: Final = ErrorCode(
+    "import-not-found", "Require that imported module can be found", "General", sub_code_of=IMPORT
+)
+IMPORT_UNTYPED: Final = ErrorCode(
+    "import-untyped", "Require that imported module has stubs", "General", sub_code_of=IMPORT
+)
+NO_REDEF: Final = ErrorCode("no-redef", "Check that each name is defined once", "General")
+FUNC_RETURNS_VALUE: Final = ErrorCode(
+    "func-returns-value", "Check that called function returns a value in value context", "General"
+)
+ABSTRACT: Final = ErrorCode(
+    "abstract", "Prevent instantiation of classes with abstract attributes", "General"
+)
+TYPE_ABSTRACT: Final = ErrorCode(
+    "type-abstract", "Require only concrete classes where Type[...] is expected", "General"
+)
+VALID_NEWTYPE: Final = ErrorCode(
+    "valid-newtype", "Check that argument 2 to NewType is valid", "General"
+)
+STRING_FORMATTING: Final = ErrorCode(
+    "str-format", "Check that string formatting/interpolation is type-safe", "General"
+)
+STR_BYTES_PY3: Final = ErrorCode(
+    "str-bytes-safe", "Warn about implicit coercions related to bytes and string types", "General"
+)
+EXIT_RETURN: Final = ErrorCode(
+    "exit-return", "Warn about too general return type for '__exit__'", "General"
+)
+LITERAL_REQ: Final = ErrorCode("literal-required", "Check that value is a literal", "General")
+UNUSED_COROUTINE: Final = ErrorCode(
+    "unused-coroutine", "Ensure that all coroutines are used", "General"
+)
+# TODO: why do we need the explicit type here? Without it mypyc CI builds fail with
+# mypy/message_registry.py:37: error: Cannot determine type of "EMPTY_BODY"  [has-type]
+EMPTY_BODY: Final[ErrorCode] = ErrorCode(
+    "empty-body",
+    "A dedicated error code to opt out return errors for empty/trivial bodies",
+    "General",
+)
+SAFE_SUPER: Final = ErrorCode(
+    "safe-super", "Warn about calls to abstract methods with empty/trivial bodies", "General"
+)
+TOP_LEVEL_AWAIT: Final = ErrorCode(
+    "top-level-await", "Warn about top level await expressions", "General"
+)
+AWAIT_NOT_ASYNC: Final = ErrorCode(
+    "await-not-async", 'Warn about "await" outside coroutine ("async def")', "General"
+)
+# These error codes aren't enabled by default.
+NO_UNTYPED_DEF: Final[ErrorCode] = ErrorCode(
+    "no-untyped-def", "Check that every function has an annotation", "General"
+)
+NO_UNTYPED_CALL: Final = ErrorCode(
+    "no-untyped-call",
+    "Disallow calling functions without type annotations from annotated functions",
+    "General",
+)
+REDUNDANT_CAST: Final = ErrorCode(
+    "redundant-cast", "Check that cast changes type of expression", "General"
+)
+ASSERT_TYPE: Final = ErrorCode("assert-type", "Check that assert_type() call succeeds", "General")
+COMPARISON_OVERLAP: Final = ErrorCode(
+    "comparison-overlap", "Check that types in comparisons and 'in' expressions overlap", "General"
+)
+NO_ANY_UNIMPORTED: Final = ErrorCode(
+    "no-any-unimported", 'Reject "Any" types from unfollowed imports', "General"
+)
+NO_ANY_RETURN: Final = ErrorCode(
+    "no-any-return",
+    'Reject returning value with "Any" type if return type is not "Any"',
+    "General",
+)
+UNREACHABLE: Final = ErrorCode(
+    "unreachable", "Warn about unreachable statements or expressions", "General"
+)
+ANNOTATION_UNCHECKED = ErrorCode(
+    "annotation-unchecked", "Notify about type annotations in unchecked functions", "General"
+)
+POSSIBLY_UNDEFINED: Final[ErrorCode] = ErrorCode(
+    "possibly-undefined",
+    "Warn about variables that are defined only in some execution paths",
+    "General",
+    default_enabled=False,
+)
+REDUNDANT_EXPR: Final = ErrorCode(
+    "redundant-expr", "Warn about redundant expressions", "General", default_enabled=False
+)
+TRUTHY_BOOL: Final[ErrorCode] = ErrorCode(
+    "truthy-bool",
+    "Warn about expressions that could always evaluate to true in boolean contexts",
+    "General",
+    default_enabled=False,
+)
+TRUTHY_FUNCTION: Final[ErrorCode] = ErrorCode(
+    "truthy-function",
+    "Warn about function that always evaluate to true in boolean contexts",
+    "General",
+)
+TRUTHY_ITERABLE: Final[ErrorCode] = ErrorCode(
+    "truthy-iterable",
+    "Warn about Iterable expressions that could always evaluate to true in boolean contexts",
+    "General",
+    default_enabled=False,
+)
+NAME_MATCH: Final = ErrorCode(
+    "name-match", "Check that type definition has consistent naming", "General"
+)
+NO_OVERLOAD_IMPL: Final = ErrorCode(
+    "no-overload-impl",
+    "Check that overloaded functions outside stub files have an implementation",
+    "General",
+)
+IGNORE_WITHOUT_CODE: Final = ErrorCode(
+    "ignore-without-code",
+    "Warn about '# type: ignore' comments which do not have error codes",
+    "General",
+    default_enabled=False,
+)
+UNUSED_AWAITABLE: Final = ErrorCode(
+    "unused-awaitable",
+    "Ensure that all awaitable values are used",
+    "General",
+    default_enabled=False,
+)
+REDUNDANT_SELF_TYPE = ErrorCode(
+    "redundant-self",
+    "Warn about redundant Self type annotations on method first argument",
+    "General",
+    default_enabled=False,
+)
+USED_BEFORE_DEF: Final[ErrorCode] = ErrorCode(
+    "used-before-def", "Warn about variables that are used before they are defined", "General"
+)
+UNUSED_IGNORE: Final = ErrorCode(
+    "unused-ignore", "Ensure that all type ignores are used", "General", default_enabled=False
+)
+EXPLICIT_OVERRIDE_REQUIRED: Final = ErrorCode(
+    "explicit-override",
+    "Require @override decorator if method is overriding a base class method",
+    "General",
+    default_enabled=False,
+)
+UNIMPORTED_REVEAL: Final = ErrorCode(
+    "unimported-reveal",
+    "Require explicit import from typing or typing_extensions for reveal_type",
+    "General",
+    default_enabled=False,
+)
+MUTABLE_OVERRIDE: Final[ErrorCode] = ErrorCode(
+    "mutable-override",
+    "Reject covariant overrides for mutable attributes",
+    "General",
+    default_enabled=False,
+)
+
+
+# Syntax errors are often blocking.
+SYNTAX: Final[ErrorCode] = ErrorCode("syntax", "Report syntax errors", "General")
+
+# This is an internal marker code for a whole-file ignore. It is not intended to
+# be user-visible.
+FILE: Final = ErrorCode("file", "Internal marker for a whole file being ignored", "General")
+del error_codes[FILE.code]
+
+# This is a catch-all for remaining uncategorized errors.
+MISC: Final = ErrorCode("misc", "Miscellaneous other checks", "General")
+
+OVERLOAD_OVERLAP: Final[ErrorCode] = ErrorCode(
+    "overload-overlap",
+    "Warn if multiple @overload variants overlap in unsafe ways",
+    "General",
+    sub_code_of=MISC,
+)
+
+# This copy will not include any error codes defined later in the plugins.
+mypy_error_codes = error_codes.copy()