Add error codes to many additional messages

mypy/build.py

@@ -57,6 +57,7 @@
 from mypy.renaming import VariableRenameVisitor
 from mypy.config_parser import parse_mypy_comments
 from mypy.freetree import free_tree
+from mypy import errorcodes as codes
 
 
 # Switch to True to produce debug output related to fine-grained incremental
@@ -2422,14 +2423,16 @@ def module_not_found(manager: BuildManager, line: int, caller_state: State,
  or (manager.options.python_version[0] >= 3
  and moduleinfo.is_py3_std_lib_module(target))):
  errors.report(
- line, 0, "No library stub file for standard library module '{}'".format(target))
+ line, 0, "No library stub file for standard library module '{}'".format(target),
+ code=codes.IMPORT)
  errors.report(line, 0, stub_msg, severity='note', only_once=True)
  elif moduleinfo.is_third_party_module(target):
- errors.report(line, 0, "No library stub file for module '{}'".format(target))
+ errors.report(line, 0, "No library stub file for module '{}'".format(target),
+ code=codes.IMPORT)
  errors.report(line, 0, stub_msg, severity='note', only_once=True)
  else:
  note = "See https://mypy.readthedocs.io/en/latest/running_mypy.html#missing-imports"
- errors.report(line, 0, "Cannot find module named '{}'".format(target))
+ errors.report(line, 0, "Cannot find module named '{}'".format(target), code=codes.IMPORT)
  errors.report(line, 0, note, severity='note', only_once=True)
  errors.set_import_context(save_import_context)
 

mypy/checker.py

@@ -70,7 +70,7 @@
 from mypy.sharedparse import BINARY_MAGIC_METHODS
 from mypy.scope import Scope
 from mypy.typeops import tuple_fallback
-from mypy import state
+from mypy import state, errorcodes as codes
 from mypy.traverser import has_return_statement
 from mypy.errorcodes import ErrorCode
 
@@ -961,7 +961,8 @@ def check_func_def(self, defn: FuncItem, typ: CallableType, name: Optional[str])
  # This is a NoReturn function
  self.msg.fail(message_registry.INVALID_IMPLICIT_RETURN, defn)
  else:
- self.msg.fail(message_registry.MISSING_RETURN_STATEMENT, defn)
+ self.msg.fail(message_registry.MISSING_RETURN_STATEMENT, defn,
+ code=codes.RETURN)
 
  self.return_types.pop()
 
@@ -980,7 +981,8 @@ def check_default_args(self, item: FuncItem, body_is_trivial: bool) -> None:
  else:
  msg += 'argument "{}"'.format(name)
  self.check_simple_assignment(arg.variable.type, arg.initializer,
- context=arg, msg=msg, lvalue_name='argument', rvalue_name='default')
+ context=arg, msg=msg, lvalue_name='argument', rvalue_name='default',
+ code=codes.ASSIGNMENT)
 
  def is_forward_op_method(self, method_name: str) -> bool:
  if self.options.python_version[0] == 2 and method_name == '__div__':
@@ -1009,24 +1011,30 @@ def is_unannotated_any(t: Type) -> bool:
  if fdef.type is None and self.options.disallow_untyped_defs:
  if (not fdef.arguments or (len(fdef.arguments) == 1 and
  (fdef.arg_names[0] == 'self' or fdef.arg_names[0] == 'cls'))):
- self.fail(message_registry.RETURN_TYPE_EXPECTED, fdef)
+ self.fail(message_registry.RETURN_TYPE_EXPECTED, fdef,
+ code=codes.NO_UNTYPED_DEF)
  if not has_return_statement(fdef):
  self.note('Use "-> None" if function does not return a value', fdef)
  else:
- self.fail(message_registry.FUNCTION_TYPE_EXPECTED, fdef)
+ self.fail(message_registry.FUNCTION_TYPE_EXPECTED, fdef,
+ code=codes.NO_UNTYPED_DEF)
  elif isinstance(fdef.type, CallableType):
  ret_type = fdef.type.ret_type
  if is_unannotated_any(ret_type):
- self.fail(message_registry.RETURN_TYPE_EXPECTED, fdef)
+ self.fail(message_registry.RETURN_TYPE_EXPECTED, fdef,
+ code=codes.NO_UNTYPED_DEF)
  elif fdef.is_generator:
  if is_unannotated_any(self.get_generator_return_type(ret_type,
  fdef.is_coroutine)):
- self.fail(message_registry.RETURN_TYPE_EXPECTED, fdef)
+ self.fail(message_registry.RETURN_TYPE_EXPECTED, fdef,
+ code=codes.NO_UNTYPED_DEF)
  elif fdef.is_coroutine and isinstance(ret_type, Instance):
  if is_unannotated_any(self.get_coroutine_return_type(ret_type)):
- self.fail(message_registry.RETURN_TYPE_EXPECTED, fdef)
+ self.fail(message_registry.RETURN_TYPE_EXPECTED, fdef,
+ code=codes.NO_UNTYPED_DEF)
  if any(is_unannotated_any(t) for t in fdef.type.arg_types):
- self.fail(message_registry.ARGUMENT_TYPE_EXPECTED, fdef)
+ self.fail(message_registry.ARGUMENT_TYPE_EXPECTED, fdef,
+ code=codes.NO_UNTYPED_DEF)
 
  def check___new___signature(self, fdef: FuncDef, typ: CallableType) -> None:
  self_type = fill_typevars_with_any(fdef.info)
@@ -1975,7 +1983,8 @@ def check_assignment(self, lvalue: Lvalue, rvalue: Expression, infer_lvalue_type
  rvalue_type, lvalue_type, infer_lvalue_type = self.check_member_assignment(
  instance_type, lvalue_type, rvalue, lvalue)
  else:
- rvalue_type = self.check_simple_assignment(lvalue_type, rvalue, lvalue)
+ rvalue_type = self.check_simple_assignment(lvalue_type, rvalue, lvalue,
+ code=codes.ASSIGNMENT)
 
  # Special case: only non-abstract non-protocol classes can be assigned to
  # variables with explicit type Type[A], where A is protocol or abstract.
@@ -2111,7 +2120,8 @@ def check_compatibility_super(self, lvalue: RefExpr, lvalue_type: Optional[Type]
  return self.check_subtype(compare_type, base_type, lvalue,
  message_registry.INCOMPATIBLE_TYPES_IN_ASSIGNMENT,
  'expression has type',
- 'base class "%s" defined the type as' % base.name())
+ 'base class "%s" defined the type as' % base.name(),
+ code=codes.ASSIGNMENT)
  return True
 
  def lvalue_type_from_base(self, expr_node: Var,
@@ -2675,7 +2685,8 @@ def check_simple_assignment(self, lvalue_type: Optional[Type], rvalue: Expressio
  context: Context,
  msg: str = message_registry.INCOMPATIBLE_TYPES_IN_ASSIGNMENT,
  lvalue_name: str = 'variable',
- rvalue_name: str = 'expression') -> Type:
+ rvalue_name: str = 'expression', *,
+ code: Optional[ErrorCode] = None) -> Type:
  if self.is_stub and isinstance(rvalue, EllipsisExpr):
  # '...' is always a valid initializer in a stub.
  return AnyType(TypeOfAny.special_form)
@@ -2690,7 +2701,7 @@ def check_simple_assignment(self, lvalue_type: Optional[Type], rvalue: Expressio
  elif lvalue_type:
  self.check_subtype(rvalue_type, lvalue_type, context, msg,
  '{} has type'.format(rvalue_name),
- '{} has type'.format(lvalue_name))
+ '{} has type'.format(lvalue_name), code=code)
  return rvalue_type
 
  def check_member_assignment(self, instance_type: Type, attribute_type: Type,
@@ -2892,7 +2903,8 @@ def check_return_stmt(self, s: ReturnStmt) -> None:
  supertype_label='expected',
  supertype=return_type,
  context=s,
- msg=message_registry.INCOMPATIBLE_RETURN_VALUE_TYPE)
+ msg=message_registry.INCOMPATIBLE_RETURN_VALUE_TYPE,
+ code=codes.RETURN_VALUE)
  else:
  # Empty returns are valid in Generators with Any typed returns, but not in
  # coroutines.
@@ -3674,7 +3686,8 @@ def find_isinstance_check(self, node: Expression
  def check_subtype(self, subtype: Type, supertype: Type, context: Context,
  msg: str = message_registry.INCOMPATIBLE_TYPES,
  subtype_label: Optional[str] = None,
- supertype_label: Optional[str] = None) -> bool:
+ supertype_label: Optional[str] = None, *,
+ code: Optional[ErrorCode] = None) -> bool:
  """Generate an error if the subtype is not compatible with
  supertype."""
  if is_subtype(subtype, supertype):
@@ -3697,7 +3710,7 @@ def check_subtype(self, subtype: Type, supertype: Type, context: Context,
  notes = append_invariance_notes([], subtype, supertype)
  if extra_info:
  msg += ' (' + ', '.join(extra_info) + ')'
- self.fail(msg, context)
+ self.fail(msg, context, code=code)
  for note in notes:
  self.msg.note(note, context)
  if note_msg:

mypy/checkexpr.py

@@ -59,6 +59,7 @@
 from mypy.visitor import ExpressionVisitor
 from mypy.plugin import Plugin, MethodContext, MethodSigContext, FunctionContext
 from mypy.typeops import tuple_fallback
+import mypy.errorcodes as codes
 
 # Type of callback user for checking individual function arguments. See
 # check_args() below for details.
@@ -483,7 +484,8 @@ def check_typeddict_call_with_kwargs(self, callee: TypedDictType,
  lvalue_type=item_expected_type, rvalue=item_value, context=item_value,
  msg=message_registry.INCOMPATIBLE_TYPES,
  lvalue_name='TypedDict item "{}"'.format(item_name),
- rvalue_name='expression')
+ rvalue_name='expression',
+ code=codes.TYPEDDICT_ITEM)
 
  return callee
 
@@ -3214,7 +3216,7 @@ def _super_arg_types(self, e: SuperExpr) -> Union[Type, Tuple[Type, Type]]:
  return AnyType(TypeOfAny.unannotated)
  elif len(e.call.args) == 0:
  if self.chk.options.python_version[0] == 2:
- self.chk.fail(message_registry.TOO_FEW_ARGS_FOR_SUPER, e)
+ self.chk.fail(message_registry.TOO_FEW_ARGS_FOR_SUPER, e, code=codes.CALL_ARG)
  return AnyType(TypeOfAny.from_error)
  elif not e.info:
  # This has already been reported by the semantic analyzer.

mypy/errorcodes.py

@@ -29,22 +29,77 @@ def __str__(self) -> str:
  'call-arg', "Check number, names and kinds of arguments in calls", 'General') # type: Final
 ARG_TYPE = ErrorCode(
  'arg-type', "Check argument types in calls", 'General') # type: Final
+CALL_OVERLOAD = ErrorCode(
+ 'call-overload', "Check that an overload variant matches arguments", 'General') # type: Final
 VALID_TYPE = ErrorCode(
  'valid-type', "Check that type (annotation) is valid", 'General') # type: Final
-MISSING_ANN = ErrorCode(
+VAR_ANNOTATED = ErrorCode(
  'var-annotated', "Require variable annotation if type can't be inferred",
  'General') # type: Final
 OVERRIDE = ErrorCode(
  'override', "Check that method override is compatible with base class",
  'General') # type: Final
+RETURN = ErrorCode(
+ 'return', "Check that function always returns a value", 'General') # type: Final
 RETURN_VALUE = ErrorCode(
  'return-value', "Check that return value is compatible with signature",
  'General') # type: Final
 ASSIGNMENT = ErrorCode(
  'assignment', "Check that assigned value is compatible with target", 'General') # type: Final
+TYPE_ARG = ErrorCode(
+ 'type-arg', "Check that generic type arguments are present", 'General') # type: Final
+TYPE_VAR = ErrorCode(
+ 'type-var', "Check that type variable values are valid", 'General') # type: Final
+UNION_ATTR = ErrorCode(
+ 'union-attr', "Check that attribute exists in each item of a union", 'General') # type: Final
+INDEX = ErrorCode(
+ 'index', "Check indexing operations", 'General') # type: Final
+OPERATOR = ErrorCode(
+ 'operator', "Check that operator is valid for operands", 'General') # type: Final
+LIST_ITEM = ErrorCode(
+ 'list-item', "Check list items in a list expression [item, ...]", 'General') # type: Final
+DICT_ITEM = ErrorCode(
+ 'dict-item',
+ "Check dict items in a dict expression {key: value, ...}", 'General') # type: Final
+TYPEDDICT_ITEM = ErrorCode(
+ 'typeddict-item', "Check items when constructing TypedDict", 'General') # type: Final
+HAS_TYPE = ErrorCode(
+ 'has-type', "Check that type of reference can be determined", 'General') # type: Final
+IMPORT = ErrorCode(
+ 'import', "Require that imported module can be found or has stubs", 'General') # type: Final
+NO_REDEF = ErrorCode(
+ 'no-redef', "Check that each name is defined once", 'General') # type: Final
+FUNC_RETURNS_VALUE = ErrorCode(
+ 'func-returns-value', "Check that called function returns a value in value context",
+ 'General') # type: Final
+ABSTRACT = ErrorCode(
+ 'abstract', "Prevent instantiation of classes with abstract attributes",
+ 'General') # type: Final
+VALID_NEWTYPE = ErrorCode(
+ 'valid-newtype', "Check that argument 2 to NewType is valid", 'General') # type: Final
+
+# These error codes aren't enable by default.
+NO_UNTYPED_DEF = ErrorCode(
+ 'no-untyped-def', "Check that every function has an annotation", 'General') # type: Final
+NO_UNTYPED_CALL = ErrorCode(
+ 'no-untyped-call',
+ "Disallow calling functions without type annotations from annotated functions",
+ 'General') # type: Final
+REDUNDANT_CAST = ErrorCode(
+ 'redundant-cast', "Check that cast changes type of expression", 'General') # type: Final
+COMPARISON_OVERLAP = ErrorCode(
+ 'comparison-overlap',
+ "Check that types in comparisons and 'in' expressions overlap", 'General') # type: Final
+NO_ANY_UNIMPORTED = ErrorCode(
+ 'no-any-unimported', 'Reject "Any" types from unfollowed imports', 'General') # type: Final
+NO_ANY_RETURN = ErrorCode(
+ 'no-any-return', 'Reject returning value with "Any" type if return type is not "Any"',
+ 'General') # type: Final
 
+# Syntax errors are often blocking.
 SYNTAX = ErrorCode(
  'syntax', "Report syntax errors", 'General') # type: Final
 
+# This is a catch-all for remaining uncategorized errors.
 MISC = ErrorCode(
  'misc', "Miscenallenous other checks", 'General') # type: Final

mypy/fastparse.py

@@ -208,7 +208,7 @@ def parse_type_comment(type_comment: str,
  if errors is not None:
  stripped_type = type_comment.split("#", 2)[0].strip()
  err_msg = "{} '{}'".format(TYPE_COMMENT_SYNTAX_ERROR, stripped_type)
- errors.report(line, e.offset, err_msg, blocker=True)
+ errors.report(line, e.offset, err_msg, blocker=True, code=codes.SYNTAX)
  return None, None
  else:
  raise

mypy/message_registry.py

@@ -89,8 +89,6 @@
 GENERIC_INSTANCE_VAR_CLASS_ACCESS = \
  'Access to generic instance variables via class is ambiguous' # type: Final
 BARE_GENERIC = 'Missing type parameters for generic type {}' # type: Final
-# TODO: remove when the old semantic analyzer is gone
-BARE_GENERIC_OLD = 'Missing type parameters for generic type' # type: Final
 IMPLICIT_GENERIC_ANY_BUILTIN = \
  'Implicit generic "Any". Use "{}" and specify generic parameters' # type: Final