Migrate core to use ErrorMessage class

mypy/checkmember.py

@@ -715,7 +715,7 @@ def analyze_class_attribute_access(itype: Instance,
         if is_method:
             mx.msg.cant_assign_to_method(mx.context)
         if isinstance(node.node, TypeInfo):
-            mx.msg.fail(message_registry.CANNOT_ASSIGN_TO_TYPE, mx.context)
+            mx.msg.fail(message_registry.CANNOT_ASSIGN_TO_TYPE.value, mx.context)
 
     # If a final attribute was declared on `self` in `__init__`, then it
     # can't be accessed on the class object.

mypy/errorcodes.py

@@ -28,16 +28,20 @@ def __str__(self) -> str:
         return '<ErrorCode {}>'.format(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")
+ATTR_DEFINED: Final[ErrorCode] = ErrorCode(
+    "attr-defined", "Check that attribute exists", "General"
+)
+NAME_DEFINED: Final[ErrorCode] = 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("valid-type", "Check that type (annotation) is valid", "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"
 )
@@ -53,7 +57,9 @@ def __str__(self) -> str:
 ASSIGNMENT: Final = ErrorCode(
     "assignment", "Check that assigned value is compatible with target", "General"
 )
-TYPE_ARG: Final = ErrorCode("type-arg", "Check that generic type arguments are present", "General")
+TYPE_ARG: Final[ErrorCode] = 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"
@@ -75,14 +81,16 @@ def __str__(self) -> str:
 IMPORT: Final = ErrorCode(
     "import", "Require that imported module can be found or has stubs", "General"
 )
-NO_REDEF: Final = ErrorCode("no-redef", "Check that each name is defined once", "General")
+NO_REDEF: Final[ErrorCode] = 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"
 )
-VALID_NEWTYPE: Final = ErrorCode(
+VALID_NEWTYPE: Final[ErrorCode] = ErrorCode(
     "valid-newtype", "Check that argument 2 to NewType is valid", "General"
 )
 STRING_FORMATTING: Final = ErrorCode(
@@ -139,10 +147,10 @@ def __str__(self) -> str:
     "General",
     default_enabled=False,
 )
-NAME_MATCH: Final = ErrorCode(
+NAME_MATCH: Final[ErrorCode] = ErrorCode(
     "name-match", "Check that type definition has consistent naming", "General"
 )
-NO_OVERLOAD_IMPL: Final = ErrorCode(
+NO_OVERLOAD_IMPL: Final[ErrorCode] = ErrorCode(
     "no-overload-impl",
     "Check that overloaded functions outside stub files have an implementation",
     "General",
@@ -162,7 +170,7 @@ def __str__(self) -> str:
 
 
 # Syntax errors are often blocking.
-SYNTAX: Final = ErrorCode("syntax", "Report syntax errors", "General")
+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.

mypy/fastparse.py

@@ -42,6 +42,7 @@
 )
 from mypy import defaults
 from mypy import message_registry, errorcodes as codes
+from mypy.message_registry import ErrorMessage
 from mypy.errors import Errors
 from mypy.options import Options
 from mypy.reachability import infer_reachability_of_if_statement, mark_block_unreachable
@@ -156,10 +157,6 @@ def ast3_parse(source: Union[str, bytes], filename: str, mode: str,
 MISSING_FALLBACK: Final = FakeInfo("fallback can't be filled out until semanal")
 _dummy_fallback: Final = Instance(MISSING_FALLBACK, [], -1)
 
-TYPE_COMMENT_SYNTAX_ERROR: Final = "syntax error in type comment"
-
-INVALID_TYPE_IGNORE: Final = 'Invalid "type: ignore" comment'
-
 TYPE_IGNORE_PATTERN: Final = re.compile(r'[^#]*#\s*type:\s*ignore\s*(.*)')
 
 
@@ -250,8 +247,8 @@ def parse_type_comment(type_comment: str,
     except SyntaxError:
         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, column, err_msg, blocker=True, code=codes.SYNTAX)
+            err_msg = message_registry.TYPE_COMMENT_SYNTAX_ERROR_VALUE.format(stripped_type)
+            errors.report(line, column, err_msg.value, blocker=True, code=err_msg.code)
             return None, None
         else:
             raise
@@ -263,7 +260,8 @@ def parse_type_comment(type_comment: str,
             ignored: Optional[List[str]] = parse_type_ignore_tag(tag)
             if ignored is None:
                 if errors is not None:
-                    errors.report(line, column, INVALID_TYPE_IGNORE, code=codes.SYNTAX)
+                    err_msg = message_registry.INVALID_TYPE_IGNORE
+                    errors.report(line, column, err_msg.value, code=err_msg.code)
                 else:
                     raise SyntaxError
         else:
@@ -341,21 +339,20 @@ def note(self, msg: str, line: int, column: int) -> None:
         self.errors.report(line, column, msg, severity='note', code=codes.SYNTAX)
 
     def fail(self,
-             msg: str,
+             msg: ErrorMessage,
              line: int,
              column: int,
              blocker: bool = True,
              code: codes.ErrorCode = codes.SYNTAX) -> None:
         if blocker or not self.options.ignore_errors:
-            self.errors.report(line, column, msg, blocker=blocker, code=code)
+            self.errors.report(line, column, msg.value, blocker=blocker, code=msg.code)
 
     def fail_merge_overload(self, node: IfStmt) -> None:
         self.fail(
-            "Condition can't be inferred, unable to merge overloads",
+            message_registry.FAILED_TO_MERGE_OVERLOADS,
             line=node.line,
             column=node.column,
             blocker=False,
-            code=codes.MISC,
         )
 
     def visit(self, node: Optional[AST]) -> Any:
@@ -760,7 +757,7 @@ def visit_Module(self, mod: ast3.Module) -> MypyFile:
             if parsed is not None:
                 self.type_ignores[ti.lineno] = parsed
             else:
-                self.fail(INVALID_TYPE_IGNORE, ti.lineno, -1)
+                self.fail(message_registry.INVALID_TYPE_IGNORE, ti.lineno, -1)
         body = self.fix_function_overloads(self.translate_stmt_list(mod.body, ismodule=True))
         return MypyFile(body,
                         self.imports,
@@ -833,7 +830,7 @@ def do_func_def(self, n: Union[ast3.FunctionDef, ast3.AsyncFunctionDef],
                     arg_types.insert(0, AnyType(TypeOfAny.special_form))
             except SyntaxError:
                 stripped_type = n.type_comment.split("#", 2)[0].strip()
-                err_msg = '{} "{}"'.format(TYPE_COMMENT_SYNTAX_ERROR, stripped_type)
+                err_msg = message_registry.TYPE_COMMENT_SYNTAX_ERROR_VALUE.format(stripped_type)
                 self.fail(err_msg, lineno, n.col_offset)
                 if n.type_comment and n.type_comment[0] not in ["(", "#"]:
                     self.note('Suggestion: wrap argument types in parentheses',
@@ -852,13 +849,12 @@ def do_func_def(self, n: Union[ast3.FunctionDef, ast3.AsyncFunctionDef],
         if any(arg_types) or return_type:
             if len(arg_types) != 1 and any(isinstance(t, EllipsisType)
                                            for t in arg_types):
-                self.fail("Ellipses cannot accompany other argument types "
-                          "in function type signature", lineno, n.col_offset)
+                self.fail(message_registry.ELLIPSIS_WITH_OTHER_TYPEARGS, lineno, n.col_offset)
             elif len(arg_types) > len(arg_kinds):
-                self.fail('Type signature has too many arguments', lineno, n.col_offset,
+                self.fail(message_registry.TYPE_SIGNATURE_TOO_MANY_ARGS, lineno, n.col_offset,
                           blocker=False)
             elif len(arg_types) < len(arg_kinds):
-                self.fail('Type signature has too few arguments', lineno, n.col_offset,
+                self.fail(message_registry.TYPE_SIGNATURE_TOO_FEW_ARGS, lineno, n.col_offset,
                           blocker=False)
             else:
                 func_type = CallableType([a if a is not None else
@@ -986,7 +982,7 @@ def make_argument(self, arg: ast3.arg, default: Optional[ast3.expr], kind: ArgKi
 
         return Argument(Var(arg.arg), arg_type, self.visit(default), kind, pos_only)
 
-    def fail_arg(self, msg: str, arg: ast3.arg) -> None:
+    def fail_arg(self, msg: ErrorMessage, arg: ast3.arg) -> None:
         self.fail(msg, arg.lineno, arg.col_offset)
 
     # ClassDef(identifier name,
@@ -1687,9 +1683,9 @@ def parent(self) -> Optional[AST]:
             return None
         return self.node_stack[-2]
 
-    def fail(self, msg: str, line: int, column: int) -> None:
+    def fail(self, msg: ErrorMessage, line: int, column: int) -> None:
         if self.errors:
-            self.errors.report(line, column, msg, blocker=True, code=codes.SYNTAX)
+            self.errors.report(line, column, msg.value, blocker=True, code=msg.code)
 
     def note(self, msg: str, line: int, column: int) -> None:
         if self.errors:
@@ -1720,7 +1716,7 @@ def visit_Call(self, e: Call) -> Type:
                 note = "Suggestion: use {0}[...] instead of {0}(...)".format(constructor)
             return self.invalid_type(e, note=note)
         if not constructor:
-            self.fail("Expected arg constructor name", e.lineno, e.col_offset)
+            self.fail(message_registry.ARG_CONSTRUCTOR_NAME_EXPECTED, e.lineno, e.col_offset)
 
         name: Optional[str] = None
         default_type = AnyType(TypeOfAny.special_form)
@@ -1733,25 +1729,25 @@ def visit_Call(self, e: Call) -> Type:
             elif i == 1:
                 name = self._extract_argument_name(arg)
             else:
-                self.fail("Too many arguments for argument constructor",
+                self.fail(message_registry.ARG_CONSTRUCTOR_TOO_MANY_ARGS,
                           f.lineno, f.col_offset)
         for k in e.keywords:
             value = k.value
             if k.arg == "name":
                 if name is not None:
-                    self.fail('"{}" gets multiple values for keyword argument "name"'.format(
+                    self.fail(message_registry.MULTIPLE_VALUES_FOR_NAME_KWARG.format(
                         constructor), f.lineno, f.col_offset)
                 name = self._extract_argument_name(value)
             elif k.arg == "type":
                 if typ is not default_type:
-                    self.fail('"{}" gets multiple values for keyword argument "type"'.format(
+                    self.fail(message_registry.MULTIPLE_VALUES_FOR_TYPE_KWARG.format(
                         constructor), f.lineno, f.col_offset)
                 converted = self.visit(value)
                 assert converted is not None
                 typ = converted
             else:
                 self.fail(
-                    'Unexpected argument "{}" for argument constructor'.format(k.arg),
+                    message_registry.ARG_CONSTRUCTOR_UNEXPECTED_ARG.format(k.arg),
                     value.lineno, value.col_offset)
         return CallableArgument(typ, name, constructor, e.lineno, e.col_offset)
 
@@ -1763,7 +1759,7 @@ def _extract_argument_name(self, n: ast3.expr) -> Optional[str]:
             return n.s.strip()
         elif isinstance(n, NameConstant) and str(n.value) == 'None':
             return None
-        self.fail('Expected string literal for argument name, got {}'.format(
+        self.fail(message_registry.ARG_NAME_EXPECTED_STRING_LITERAL.format(
             type(n).__name__), self.line, 0)
         return None
 

mypy/fastparse2.py

@@ -44,11 +44,12 @@
     Type, CallableType, AnyType, UnboundType, EllipsisType, TypeOfAny, Instance,
     ProperType
 )
+from mypy.message_registry import ErrorMessage
 from mypy import message_registry, errorcodes as codes
 from mypy.errors import Errors
 from mypy.fastparse import (
     TypeConverter, parse_type_comment, parse_type_ignore_tag,
-    TYPE_IGNORE_PATTERN, INVALID_TYPE_IGNORE
+    TYPE_IGNORE_PATTERN
 )
 from mypy.options import Options
 from mypy.util import bytes_to_human_readable_repr
@@ -176,9 +177,9 @@ def __init__(self,
 
         self.type_ignores: Dict[int, List[str]] = {}
 
-    def fail(self, msg: str, line: int, column: int, blocker: bool = True) -> None:
+    def fail(self, msg: ErrorMessage, line: int, column: int, blocker: bool = True) -> None:
         if blocker or not self.options.ignore_errors:
-            self.errors.report(line, column, msg, blocker=blocker, code=codes.SYNTAX)
+            self.errors.report(line, column, msg.value, blocker=blocker, code=msg.code)
 
     def visit(self, node: Optional[AST]) -> Any:  # same as in typed_ast stub
         if node is None:
@@ -353,7 +354,7 @@ def visit_Module(self, mod: ast27.Module) -> MypyFile:
             if parsed is not None:
                 self.type_ignores[ti.lineno] = parsed
             else:
-                self.fail(INVALID_TYPE_IGNORE, ti.lineno, -1)
+                self.fail(message_registry.INVALID_TYPE_IGNORE, ti.lineno, -1)
         body = self.fix_function_overloads(self.translate_stmt_list(mod.body, module=True))
         return MypyFile(body,
                         self.imports,
@@ -408,7 +409,7 @@ def visit_FunctionDef(self, n: ast27.FunctionDef) -> Statement:
                     arg_types.insert(0, AnyType(TypeOfAny.special_form))
             except SyntaxError:
                 stripped_type = type_comment.split("#", 2)[0].strip()
-                err_msg = '{} "{}"'.format(TYPE_COMMENT_SYNTAX_ERROR, stripped_type)
+                err_msg = message_registry.TYPE_COMMENT_SYNTAX_ERROR_VALUE.format(stripped_type)
                 self.fail(err_msg, lineno, n.col_offset)
                 arg_types = [AnyType(TypeOfAny.from_error)] * len(args)
                 return_type = AnyType(TypeOfAny.from_error)
@@ -423,13 +424,12 @@ def visit_FunctionDef(self, n: ast27.FunctionDef) -> Statement:
         if any(arg_types) or return_type:
             if len(arg_types) != 1 and any(isinstance(t, EllipsisType)
                                            for t in arg_types):
-                self.fail("Ellipses cannot accompany other argument types "
-                          "in function type signature", lineno, n.col_offset)
+                self.fail(message_registry.ELLIPSIS_WITH_OTHER_TYPEARGS, lineno, n.col_offset)
             elif len(arg_types) > len(arg_kinds):
-                self.fail('Type signature has too many arguments', lineno, n.col_offset,
+                self.fail(message_registry.TYPE_SIGNATURE_TOO_MANY_ARGS, lineno, n.col_offset,
                           blocker=False)
             elif len(arg_types) < len(arg_kinds):
-                self.fail('Type signature has too few arguments', lineno, n.col_offset,
+                self.fail(message_registry.TYPE_SIGNATURE_TOO_FEW_ARGS, lineno, n.col_offset,
                           blocker=False)
             else:
                 any_type = AnyType(TypeOfAny.unannotated)
@@ -526,7 +526,7 @@ def transform_args(self,
                 arg.pos_only = True
 
         # We don't have any context object to give, but we have closed around the line num
-        def fail_arg(msg: str, arg: None) -> None:
+        def fail_arg(msg: ErrorMessage, arg: None) -> None:
             self.fail(msg, line, 0)
         check_arg_names(names, [None] * len(names), fail_arg)
 
@@ -568,7 +568,7 @@ def get_type(self,
                     tag: Optional[str] = cast(Any, extra_ignore).group(1)
                     ignored = parse_type_ignore_tag(tag)
                     if ignored is None:
-                        self.fail(INVALID_TYPE_IGNORE, converter.line, -1)
+                        self.fail(message_registry.INVALID_TYPE_IGNORE, converter.line, -1)
                     else:
                         self.type_ignores[converter.line] = ignored
                 return typ
@@ -709,7 +709,7 @@ def try_handler(self,
             elif isinstance(item.name, Name):
                 vs.append(self.set_line(NameExpr(item.name.id), item))
             else:
-                self.fail('Sorry, "except <expr>, <anything but a name>" is not supported',
+                self.fail(message_registry.EXCEPT_EXPR_NOTNAME_UNSUPPORTED,
                           item.lineno, item.col_offset)
                 vs.append(None)
         types = [self.visit(h.type) for h in handlers]