jaclang 0.7.34__py3-none-any.whl → 0.8.1__py3-none-any.whl

jaclang/vendor/mypy/dmypy_util.py

@@ -1,117 +0,0 @@
-"""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)

jaclang/vendor/mypy/erasetype.py

@@ -1,278 +0,0 @@
-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

jaclang/vendor/mypy/errorcodes.py

@@ -1,291 +0,0 @@
-"""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,
-)
-
-NARROWED_TYPE_NOT_SUBTYPE: Final[ErrorCode] = ErrorCode(
-    "narrowed-type-not-subtype",
-    "Warn if a TypeIs function's narrowed type is not a subtype of the original type",
-    "General",
-)
-
-# This copy will not include any error codes defined later in the plugins.
-mypy_error_codes = error_codes.copy()