| | """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_TYPE_RAW_ENUM_VALUE: Final = ErrorMessage( |
| | "Invalid type: try using Literal[{}.{}] instead?", codes.VALID_TYPE |
| | ) |
| |
|
| | |
| | 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 |
| | ) |
| | COVARIANT_OVERRIDE_OF_MUTABLE_ATTRIBUTE: Final = ErrorMessage( |
| | "Covariant override of a mutable attribute", code=codes.MUTABLE_OVERRIDE |
| | ) |
| | 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") |
| | AMBIGUOUS_SLICE_OF_VARIADIC_TUPLE: Final = ErrorMessage("Ambiguous slice of a variadic tuple") |
| | TOO_MANY_TARGETS_FOR_VARIADIC_UNPACK: Final = ErrorMessage( |
| | "Too many assignment targets for variadic unpack" |
| | ) |
| | 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" |
| | ) |
| | TYPEDDICT_OVERRIDE_MERGE: Final = 'Overwriting TypedDict field "{}" while merging' |
| | 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_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" |
| | INVALID_PARAM_SPEC_LOCATION: Final = "Invalid location for ParamSpec {}" |
| | INVALID_PARAM_SPEC_LOCATION_NOTE: Final = ( |
| | 'You can use ParamSpec as the first argument to Callable, e.g., "Callable[{}, int]"' |
| | ) |
| |
|
| | |
| | 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" |
| | ) |
| | TYPE_PARAMETERS_SHOULD_BE_DECLARED: Final = ( |
| | "All type parameters should be declared ({} not declared)" |
| | ) |
| |
|
| | |
| | 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 two positional arguments in enclosing function' |
| | ) |
| |
|
| | |
| | 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 "{}"' |
| | ) |
| |
|
| | |
| | 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_MEMBERS_ATTR_WILL_BE_OVERRIDEN: Final = ErrorMessage( |
| | 'Assigned "__members__" will be overridden by "Enum" internally' |
| | ) |
| |
|
| | |
| | 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" |
| |
|
| | |
| | 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 {} requires positional argument") |
| |
|
| | |
| | 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' |
| |
|
| | |
| | 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 |
| | ) |
| | NARROWED_TYPE_NOT_SUBTYPE: Final = ErrorMessage( |
| | "Narrowed type {} is not a subtype of input type {}", codes.NARROWED_TYPE_NOT_SUBTYPE |
| | ) |
| | TYPE_VAR_TOO_FEW_CONSTRAINED_TYPES: Final = ErrorMessage( |
| | "Type variable must have at least two constrained types", codes.MISC |
| | ) |
| |
|
| | TYPE_VAR_YIELD_EXPRESSION_IN_BOUND: Final = ErrorMessage( |
| | "Yield expression cannot be used as a type variable bound", codes.SYNTAX |
| | ) |
| |
|
| | TYPE_VAR_NAMED_EXPRESSION_IN_BOUND: Final = ErrorMessage( |
| | "Named expression cannot be used as a type variable bound", codes.SYNTAX |
| | ) |
| |
|
| | TYPE_VAR_AWAIT_EXPRESSION_IN_BOUND: Final = ErrorMessage( |
| | "Await expression cannot be used as a type variable bound", codes.SYNTAX |
| | ) |
| |
|
| | TYPE_VAR_GENERIC_CONSTRAINT_TYPE: Final = ErrorMessage( |
| | "TypeVar constraint type cannot be parametrized by type variables", codes.MISC |
| | ) |
| |
|
| | TYPE_ALIAS_WITH_YIELD_EXPRESSION: Final = ErrorMessage( |
| | "Yield expression cannot be used within a type alias", codes.SYNTAX |
| | ) |
| |
|
| | TYPE_ALIAS_WITH_NAMED_EXPRESSION: Final = ErrorMessage( |
| | "Named expression cannot be used within a type alias", codes.SYNTAX |
| | ) |
| |
|
| | TYPE_ALIAS_WITH_AWAIT_EXPRESSION: Final = ErrorMessage( |
| | "Await expression cannot be used within a type alias", codes.SYNTAX |
| | ) |
| |
|
