260 lines
12 KiB
Python
260 lines
12 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 typing import NamedTuple, Optional
|
||
|
|
from typing_extensions import Final
|
||
|
|
|
||
|
|
from mypy import errorcodes as codes
|
||
|
|
|
||
|
|
|
||
|
|
class ErrorMessage(NamedTuple):
|
||
|
|
value: str
|
||
|
|
code: Optional[codes.ErrorCode] = None
|
||
|
|
|
||
|
|
def format(self, *args: object, **kwargs: object) -> "ErrorMessage":
|
||
|
|
return ErrorMessage(self.value.format(*args, **kwargs), code=self.code)
|
||
|
|
|
||
|
|
|
||
|
|
# Invalid types
|
||
|
|
INVALID_TYPE_RAW_ENUM_VALUE: Final = "Invalid type: try using Literal[{}.{}] instead?"
|
||
|
|
|
||
|
|
# 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)
|
||
|
|
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")
|
||
|
|
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"
|
||
|
|
)
|
||
|
|
INVALID_GENERATOR_RETURN_ITEM_TYPE: Final = ErrorMessage(
|
||
|
|
"The return type of a generator function must be None in"
|
||
|
|
" its third type parameter in Python 2"
|
||
|
|
)
|
||
|
|
YIELD_VALUE_EXPECTED: Final = ErrorMessage("Yield value expected")
|
||
|
|
INCOMPATIBLE_TYPES: Final = "Incompatible types"
|
||
|
|
INCOMPATIBLE_TYPES_IN_ASSIGNMENT: Final = "Incompatible types in 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')
|
||
|
|
INVALID_TUPLE_INDEX_TYPE: Final = ErrorMessage("Invalid tuple index type")
|
||
|
|
TUPLE_INDEX_OUT_OF_RANGE: Final = ErrorMessage("Tuple index out of range")
|
||
|
|
INVALID_SLICE_INDEX: Final = ErrorMessage("Slice index must be an integer or None")
|
||
|
|
CANNOT_INFER_LAMBDA_TYPE: Final = ErrorMessage("Cannot infer type of lambda")
|
||
|
|
CANNOT_ACCESS_INIT: Final = 'Cannot access "__init__" directly'
|
||
|
|
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 = "Incompatible import of"
|
||
|
|
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 = "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"
|
||
|
|
)
|
||
|
|
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_BOOL,
|
||
|
|
)
|
||
|
|
NOT_CALLABLE: Final = '{} not callable'
|
||
|
|
PYTHON2_PRINT_FILE_TYPE: Final = (
|
||
|
|
'Argument "file" to "print" has incompatible type "{}"; expected "{}"'
|
||
|
|
)
|
||
|
|
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 = "{} cannot be unpacked (must be tuple or TypeVarTuple)"
|
||
|
|
|
||
|
|
# 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_BOUND_MUST_BE_TYPE: Final = 'TypeVar "bound" must be a type'
|
||
|
|
TYPEVAR_UNEXPECTED_ARGUMENT: Final = 'Unexpected argument to "TypeVar()"'
|
||
|
|
|
||
|
|
# Super
|
||
|
|
TOO_MANY_ARGS_FOR_SUPER: Final = ErrorMessage('Too many arguments for "super"')
|
||
|
|
TOO_FEW_ARGS_FOR_SUPER: Final = ErrorMessage('Too few arguments for "super"', codes.CALL_ARG)
|
||
|
|
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 "{}"'
|
||
|
|
)
|
||
|
|
INVALID_SELF_TYPE_OR_EXTRA_ARG: Final = ErrorMessage(
|
||
|
|
"Invalid type for self, or extra argument type in function annotation"
|
||
|
|
)
|
||
|
|
|
||
|
|
# 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_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 "{}"'
|
||
|
|
MULTIPLE_ASSIGNMENTS_IN_PATTERN: Final = 'Multiple assignments to name "{}" in pattern'
|
||
|
|
CANNOT_MODIFY_MATCH_ARGS: Final = 'Cannot assign to "__match_args__"'
|