Tipragot
628be439b8
Cela permet de ne pas avoir de problèmes de compatibilité car python est dans le git.
320 lines
15 KiB
Python
320 lines
15 KiB
Python
"""Message constants for generating error messages during type checking.
|
|
|
|
Literal messages should be defined as constants in this module so they won't get out of sync
|
|
if used in more than one place, and so that they can be easily introspected. These messages are
|
|
ultimately consumed by messages.MessageBuilder.fail(). For more non-trivial message generation,
|
|
add a method to MessageBuilder and call this instead.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Final, NamedTuple
|
|
|
|
from mypy import errorcodes as codes
|
|
|
|
|
|
class ErrorMessage(NamedTuple):
|
|
value: str
|
|
code: codes.ErrorCode | None = None
|
|
|
|
def format(self, *args: object, **kwargs: object) -> ErrorMessage:
|
|
return ErrorMessage(self.value.format(*args, **kwargs), code=self.code)
|
|
|
|
def with_additional_msg(self, info: str) -> ErrorMessage:
|
|
return ErrorMessage(self.value + info, code=self.code)
|
|
|
|
|
|
# Invalid types
|
|
INVALID_TYPE_RAW_ENUM_VALUE: Final = ErrorMessage(
|
|
"Invalid type: try using Literal[{}.{}] instead?", codes.VALID_TYPE
|
|
)
|
|
|
|
# Type checker error message constants
|
|
NO_RETURN_VALUE_EXPECTED: Final = ErrorMessage("No return value expected", codes.RETURN_VALUE)
|
|
MISSING_RETURN_STATEMENT: Final = ErrorMessage("Missing return statement", codes.RETURN)
|
|
EMPTY_BODY_ABSTRACT: Final = ErrorMessage(
|
|
"If the method is meant to be abstract, use @abc.abstractmethod", codes.EMPTY_BODY
|
|
)
|
|
INVALID_IMPLICIT_RETURN: Final = ErrorMessage("Implicit return in function which does not return")
|
|
INCOMPATIBLE_RETURN_VALUE_TYPE: Final = ErrorMessage(
|
|
"Incompatible return value type", codes.RETURN_VALUE
|
|
)
|
|
RETURN_VALUE_EXPECTED: Final = ErrorMessage("Return value expected", codes.RETURN_VALUE)
|
|
NO_RETURN_EXPECTED: Final = ErrorMessage("Return statement in function which does not return")
|
|
INVALID_EXCEPTION: Final = ErrorMessage("Exception must be derived from BaseException")
|
|
INVALID_EXCEPTION_TYPE: Final = ErrorMessage(
|
|
"Exception type must be derived from BaseException (or be a tuple of exception classes)"
|
|
)
|
|
INVALID_EXCEPTION_GROUP: Final = ErrorMessage(
|
|
"Exception type in except* cannot derive from BaseExceptionGroup"
|
|
)
|
|
RETURN_IN_ASYNC_GENERATOR: Final = ErrorMessage(
|
|
'"return" with value in async generator is not allowed'
|
|
)
|
|
INVALID_RETURN_TYPE_FOR_GENERATOR: Final = ErrorMessage(
|
|
'The return type of a generator function should be "Generator"' " or one of its supertypes"
|
|
)
|
|
INVALID_RETURN_TYPE_FOR_ASYNC_GENERATOR: Final = ErrorMessage(
|
|
'The return type of an async generator function should be "AsyncGenerator" or one of its '
|
|
"supertypes"
|
|
)
|
|
YIELD_VALUE_EXPECTED: Final = ErrorMessage("Yield value expected")
|
|
INCOMPATIBLE_TYPES: Final = ErrorMessage("Incompatible types")
|
|
INCOMPATIBLE_TYPES_IN_ASSIGNMENT: Final = ErrorMessage(
|
|
"Incompatible types in assignment", code=codes.ASSIGNMENT
|
|
)
|
|
INCOMPATIBLE_TYPES_IN_AWAIT: Final = ErrorMessage('Incompatible types in "await"')
|
|
INCOMPATIBLE_REDEFINITION: Final = ErrorMessage("Incompatible redefinition")
|
|
INCOMPATIBLE_TYPES_IN_ASYNC_WITH_AENTER: Final = (
|
|
'Incompatible types in "async with" for "__aenter__"'
|
|
)
|
|
INCOMPATIBLE_TYPES_IN_ASYNC_WITH_AEXIT: Final = (
|
|
'Incompatible types in "async with" for "__aexit__"'
|
|
)
|
|
INCOMPATIBLE_TYPES_IN_ASYNC_FOR: Final = 'Incompatible types in "async for"'
|
|
INVALID_TYPE_FOR_SLOTS: Final = 'Invalid type for "__slots__"'
|
|
|
|
ASYNC_FOR_OUTSIDE_COROUTINE: Final = '"async for" outside async function'
|
|
ASYNC_WITH_OUTSIDE_COROUTINE: Final = '"async with" outside async function'
|
|
|
|
INCOMPATIBLE_TYPES_IN_YIELD: Final = ErrorMessage('Incompatible types in "yield"')
|
|
INCOMPATIBLE_TYPES_IN_YIELD_FROM: Final = ErrorMessage('Incompatible types in "yield from"')
|
|
INCOMPATIBLE_TYPES_IN_STR_INTERPOLATION: Final = "Incompatible types in string interpolation"
|
|
INCOMPATIBLE_TYPES_IN_CAPTURE: Final = ErrorMessage("Incompatible types in capture pattern")
|
|
MUST_HAVE_NONE_RETURN_TYPE: Final = ErrorMessage('The return type of "{}" must be None')
|
|
TUPLE_INDEX_OUT_OF_RANGE: Final = ErrorMessage("Tuple index out of range")
|
|
INVALID_SLICE_INDEX: Final = ErrorMessage("Slice index must be an integer, SupportsIndex or None")
|
|
CANNOT_INFER_LAMBDA_TYPE: Final = ErrorMessage("Cannot infer type of lambda")
|
|
CANNOT_ACCESS_INIT: Final = (
|
|
'Accessing "__init__" on an instance is unsound, since instance.__init__ could be from'
|
|
" an incompatible subclass"
|
|
)
|
|
NON_INSTANCE_NEW_TYPE: Final = ErrorMessage('"__new__" must return a class instance (got {})')
|
|
INVALID_NEW_TYPE: Final = ErrorMessage('Incompatible return type for "__new__"')
|
|
BAD_CONSTRUCTOR_TYPE: Final = ErrorMessage("Unsupported decorated constructor type")
|
|
CANNOT_ASSIGN_TO_METHOD: Final = "Cannot assign to a method"
|
|
CANNOT_ASSIGN_TO_TYPE: Final = "Cannot assign to a type"
|
|
INCONSISTENT_ABSTRACT_OVERLOAD: Final = ErrorMessage(
|
|
"Overloaded method has both abstract and non-abstract variants"
|
|
)
|
|
MULTIPLE_OVERLOADS_REQUIRED: Final = ErrorMessage("Single overload definition, multiple required")
|
|
READ_ONLY_PROPERTY_OVERRIDES_READ_WRITE: Final = ErrorMessage(
|
|
"Read-only property cannot override read-write property"
|
|
)
|
|
FORMAT_REQUIRES_MAPPING: Final = "Format requires a mapping"
|
|
RETURN_TYPE_CANNOT_BE_CONTRAVARIANT: Final = ErrorMessage(
|
|
"Cannot use a contravariant type variable as return type"
|
|
)
|
|
FUNCTION_PARAMETER_CANNOT_BE_COVARIANT: Final = ErrorMessage(
|
|
"Cannot use a covariant type variable as a parameter"
|
|
)
|
|
INCOMPATIBLE_IMPORT_OF: Final = ErrorMessage('Incompatible import of "{}"', code=codes.ASSIGNMENT)
|
|
FUNCTION_TYPE_EXPECTED: Final = ErrorMessage(
|
|
"Function is missing a type annotation", codes.NO_UNTYPED_DEF
|
|
)
|
|
ONLY_CLASS_APPLICATION: Final = ErrorMessage(
|
|
"Type application is only supported for generic classes"
|
|
)
|
|
RETURN_TYPE_EXPECTED: Final = ErrorMessage(
|
|
"Function is missing a return type annotation", codes.NO_UNTYPED_DEF
|
|
)
|
|
ARGUMENT_TYPE_EXPECTED: Final = ErrorMessage(
|
|
"Function is missing a type annotation for one or more arguments", codes.NO_UNTYPED_DEF
|
|
)
|
|
KEYWORD_ARGUMENT_REQUIRES_STR_KEY_TYPE: Final = ErrorMessage(
|
|
'Keyword argument only valid with "str" key type in call to "dict"'
|
|
)
|
|
ALL_MUST_BE_SEQ_STR: Final = ErrorMessage("Type of __all__ must be {}, not {}")
|
|
INVALID_TYPEDDICT_ARGS: Final = ErrorMessage(
|
|
"Expected keyword arguments, {...}, or dict(...) in TypedDict constructor"
|
|
)
|
|
TYPEDDICT_KEY_MUST_BE_STRING_LITERAL: Final = ErrorMessage(
|
|
"Expected TypedDict key to be string literal"
|
|
)
|
|
MALFORMED_ASSERT: Final = ErrorMessage("Assertion is always true, perhaps remove parentheses?")
|
|
DUPLICATE_TYPE_SIGNATURES: Final = ErrorMessage("Function has duplicate type signatures")
|
|
DESCRIPTOR_SET_NOT_CALLABLE: Final = ErrorMessage("{}.__set__ is not callable")
|
|
DESCRIPTOR_GET_NOT_CALLABLE: Final = "{}.__get__ is not callable"
|
|
MODULE_LEVEL_GETATTRIBUTE: Final = ErrorMessage(
|
|
"__getattribute__ is not valid at the module level"
|
|
)
|
|
CLASS_VAR_CONFLICTS_SLOTS: Final = '"{}" in __slots__ conflicts with class variable access'
|
|
NAME_NOT_IN_SLOTS: Final = ErrorMessage(
|
|
'Trying to assign name "{}" that is not in "__slots__" of type "{}"'
|
|
)
|
|
TYPE_ALWAYS_TRUE: Final = ErrorMessage(
|
|
"{} which does not implement __bool__ or __len__ "
|
|
"so it could always be true in boolean context",
|
|
code=codes.TRUTHY_BOOL,
|
|
)
|
|
TYPE_ALWAYS_TRUE_UNIONTYPE: Final = ErrorMessage(
|
|
"{} of which no members implement __bool__ or __len__ "
|
|
"so it could always be true in boolean context",
|
|
code=codes.TRUTHY_BOOL,
|
|
)
|
|
FUNCTION_ALWAYS_TRUE: Final = ErrorMessage(
|
|
"Function {} could always be true in boolean context", code=codes.TRUTHY_FUNCTION
|
|
)
|
|
ITERABLE_ALWAYS_TRUE: Final = ErrorMessage(
|
|
"{} which can always be true in boolean context. Consider using {} instead.",
|
|
code=codes.TRUTHY_ITERABLE,
|
|
)
|
|
NOT_CALLABLE: Final = "{} not callable"
|
|
TYPE_MUST_BE_USED: Final = "Value of type {} must be used"
|
|
|
|
# Generic
|
|
GENERIC_INSTANCE_VAR_CLASS_ACCESS: Final = (
|
|
"Access to generic instance variables via class is ambiguous"
|
|
)
|
|
GENERIC_CLASS_VAR_ACCESS: Final = "Access to generic class variables is ambiguous"
|
|
BARE_GENERIC: Final = "Missing type parameters for generic type {}"
|
|
IMPLICIT_GENERIC_ANY_BUILTIN: Final = (
|
|
'Implicit generic "Any". Use "{}" and specify generic parameters'
|
|
)
|
|
INVALID_UNPACK: Final = "{} cannot be unpacked (must be tuple or TypeVarTuple)"
|
|
INVALID_UNPACK_POSITION: Final = "Unpack is only valid in a variadic position"
|
|
|
|
# TypeVar
|
|
INCOMPATIBLE_TYPEVAR_VALUE: Final = 'Value of type variable "{}" of {} cannot be {}'
|
|
CANNOT_USE_TYPEVAR_AS_EXPRESSION: Final = 'Type variable "{}.{}" cannot be used as an expression'
|
|
INVALID_TYPEVAR_AS_TYPEARG: Final = 'Type variable "{}" not valid as type argument value for "{}"'
|
|
INVALID_TYPEVAR_ARG_BOUND: Final = 'Type argument {} of "{}" must be a subtype of {}'
|
|
INVALID_TYPEVAR_ARG_VALUE: Final = 'Invalid type argument value for "{}"'
|
|
TYPEVAR_VARIANCE_DEF: Final = 'TypeVar "{}" may only be a literal bool'
|
|
TYPEVAR_ARG_MUST_BE_TYPE: Final = '{} "{}" must be a type'
|
|
TYPEVAR_UNEXPECTED_ARGUMENT: Final = 'Unexpected argument to "TypeVar()"'
|
|
UNBOUND_TYPEVAR: Final = (
|
|
"A function returning TypeVar should receive at least "
|
|
"one argument containing the same TypeVar"
|
|
)
|
|
|
|
# Super
|
|
TOO_MANY_ARGS_FOR_SUPER: Final = ErrorMessage('Too many arguments for "super"')
|
|
SUPER_WITH_SINGLE_ARG_NOT_SUPPORTED: Final = ErrorMessage(
|
|
'"super" with a single argument not supported'
|
|
)
|
|
UNSUPPORTED_ARG_1_FOR_SUPER: Final = ErrorMessage('Unsupported argument 1 for "super"')
|
|
UNSUPPORTED_ARG_2_FOR_SUPER: Final = ErrorMessage('Unsupported argument 2 for "super"')
|
|
SUPER_VARARGS_NOT_SUPPORTED: Final = ErrorMessage('Varargs not supported with "super"')
|
|
SUPER_POSITIONAL_ARGS_REQUIRED: Final = ErrorMessage('"super" only accepts positional arguments')
|
|
SUPER_ARG_2_NOT_INSTANCE_OF_ARG_1: Final = ErrorMessage(
|
|
'Argument 2 for "super" not an instance of argument 1'
|
|
)
|
|
TARGET_CLASS_HAS_NO_BASE_CLASS: Final = ErrorMessage("Target class has no base class")
|
|
SUPER_OUTSIDE_OF_METHOD_NOT_SUPPORTED: Final = ErrorMessage(
|
|
"super() outside of a method is not supported"
|
|
)
|
|
SUPER_ENCLOSING_POSITIONAL_ARGS_REQUIRED: Final = ErrorMessage(
|
|
"super() requires one or more positional arguments in enclosing function"
|
|
)
|
|
|
|
# Self-type
|
|
MISSING_OR_INVALID_SELF_TYPE: Final = ErrorMessage(
|
|
"Self argument missing for a non-static method (or an invalid type for self)"
|
|
)
|
|
ERASED_SELF_TYPE_NOT_SUPERTYPE: Final = ErrorMessage(
|
|
'The erased type of self "{}" is not a supertype of its class "{}"'
|
|
)
|
|
|
|
# Final
|
|
CANNOT_INHERIT_FROM_FINAL: Final = ErrorMessage('Cannot inherit from final class "{}"')
|
|
DEPENDENT_FINAL_IN_CLASS_BODY: Final = ErrorMessage(
|
|
"Final name declared in class body cannot depend on type variables"
|
|
)
|
|
CANNOT_ACCESS_FINAL_INSTANCE_ATTR: Final = (
|
|
'Cannot access final instance attribute "{}" on class object'
|
|
)
|
|
CANNOT_MAKE_DELETABLE_FINAL: Final = ErrorMessage("Deletable attribute cannot be final")
|
|
|
|
# Enum
|
|
ENUM_MEMBERS_ATTR_WILL_BE_OVERRIDEN: Final = ErrorMessage(
|
|
'Assigned "__members__" will be overridden by "Enum" internally'
|
|
)
|
|
|
|
# ClassVar
|
|
CANNOT_OVERRIDE_INSTANCE_VAR: Final = ErrorMessage(
|
|
'Cannot override instance variable (previously declared on base class "{}") with class '
|
|
"variable"
|
|
)
|
|
CANNOT_OVERRIDE_CLASS_VAR: Final = ErrorMessage(
|
|
'Cannot override class variable (previously declared on base class "{}") with instance '
|
|
"variable"
|
|
)
|
|
CLASS_VAR_WITH_TYPEVARS: Final = "ClassVar cannot contain type variables"
|
|
CLASS_VAR_WITH_GENERIC_SELF: Final = "ClassVar cannot contain Self type in generic classes"
|
|
CLASS_VAR_OUTSIDE_OF_CLASS: Final = "ClassVar can only be used for assignments in class body"
|
|
|
|
# Protocol
|
|
RUNTIME_PROTOCOL_EXPECTED: Final = ErrorMessage(
|
|
"Only @runtime_checkable protocols can be used with instance and class checks"
|
|
)
|
|
CANNOT_INSTANTIATE_PROTOCOL: Final = ErrorMessage('Cannot instantiate protocol class "{}"')
|
|
TOO_MANY_UNION_COMBINATIONS: Final = ErrorMessage(
|
|
"Not all union combinations were tried because there are too many unions"
|
|
)
|
|
|
|
CONTIGUOUS_ITERABLE_EXPECTED: Final = ErrorMessage("Contiguous iterable with same type expected")
|
|
ITERABLE_TYPE_EXPECTED: Final = ErrorMessage("Invalid type '{}' for *expr (iterable expected)")
|
|
TYPE_GUARD_POS_ARG_REQUIRED: Final = ErrorMessage("Type guard requires positional argument")
|
|
|
|
# Match Statement
|
|
MISSING_MATCH_ARGS: Final = 'Class "{}" doesn\'t define "__match_args__"'
|
|
OR_PATTERN_ALTERNATIVE_NAMES: Final = "Alternative patterns bind different names"
|
|
CLASS_PATTERN_GENERIC_TYPE_ALIAS: Final = (
|
|
"Class pattern class must not be a type alias with type parameters"
|
|
)
|
|
CLASS_PATTERN_TYPE_REQUIRED: Final = 'Expected type in class pattern; found "{}"'
|
|
CLASS_PATTERN_TOO_MANY_POSITIONAL_ARGS: Final = "Too many positional patterns for class pattern"
|
|
CLASS_PATTERN_KEYWORD_MATCHES_POSITIONAL: Final = (
|
|
'Keyword "{}" already matches a positional pattern'
|
|
)
|
|
CLASS_PATTERN_DUPLICATE_KEYWORD_PATTERN: Final = 'Duplicate keyword pattern "{}"'
|
|
CLASS_PATTERN_UNKNOWN_KEYWORD: Final = 'Class "{}" has no attribute "{}"'
|
|
CLASS_PATTERN_CLASS_OR_STATIC_METHOD: Final = "Cannot have both classmethod and staticmethod"
|
|
MULTIPLE_ASSIGNMENTS_IN_PATTERN: Final = 'Multiple assignments to name "{}" in pattern'
|
|
CANNOT_MODIFY_MATCH_ARGS: Final = 'Cannot assign to "__match_args__"'
|
|
|
|
DATACLASS_FIELD_ALIAS_MUST_BE_LITERAL: Final = (
|
|
'"alias" argument to dataclass field must be a string literal'
|
|
)
|
|
DATACLASS_POST_INIT_MUST_BE_A_FUNCTION: Final = '"__post_init__" method must be an instance method'
|
|
|
|
# fastparse
|
|
FAILED_TO_MERGE_OVERLOADS: Final = ErrorMessage(
|
|
"Condition can't be inferred, unable to merge overloads"
|
|
)
|
|
TYPE_IGNORE_WITH_ERRCODE_ON_MODULE: Final = ErrorMessage(
|
|
"type ignore with error code is not supported for modules; "
|
|
'use `# mypy: disable-error-code="{}"`',
|
|
codes.SYNTAX,
|
|
)
|
|
INVALID_TYPE_IGNORE: Final = ErrorMessage('Invalid "type: ignore" comment', codes.SYNTAX)
|
|
TYPE_COMMENT_SYNTAX_ERROR_VALUE: Final = ErrorMessage(
|
|
'Syntax error in type comment "{}"', codes.SYNTAX
|
|
)
|
|
ELLIPSIS_WITH_OTHER_TYPEARGS: Final = ErrorMessage(
|
|
"Ellipses cannot accompany other argument types in function type signature", codes.SYNTAX
|
|
)
|
|
TYPE_SIGNATURE_TOO_MANY_ARGS: Final = ErrorMessage(
|
|
"Type signature has too many arguments", codes.SYNTAX
|
|
)
|
|
TYPE_SIGNATURE_TOO_FEW_ARGS: Final = ErrorMessage(
|
|
"Type signature has too few arguments", codes.SYNTAX
|
|
)
|
|
ARG_CONSTRUCTOR_NAME_EXPECTED: Final = ErrorMessage("Expected arg constructor name", codes.SYNTAX)
|
|
ARG_CONSTRUCTOR_TOO_MANY_ARGS: Final = ErrorMessage(
|
|
"Too many arguments for argument constructor", codes.SYNTAX
|
|
)
|
|
MULTIPLE_VALUES_FOR_NAME_KWARG: Final = ErrorMessage(
|
|
'"{}" gets multiple values for keyword argument "name"', codes.SYNTAX
|
|
)
|
|
MULTIPLE_VALUES_FOR_TYPE_KWARG: Final = ErrorMessage(
|
|
'"{}" gets multiple values for keyword argument "type"', codes.SYNTAX
|
|
)
|
|
ARG_CONSTRUCTOR_UNEXPECTED_ARG: Final = ErrorMessage(
|
|
'Unexpected argument "{}" for argument constructor', codes.SYNTAX
|
|
)
|
|
ARG_NAME_EXPECTED_STRING_LITERAL: Final = ErrorMessage(
|
|
"Expected string literal for argument name, got {}", codes.SYNTAX
|
|
)
|