checker: disallow specifying both ErrorMessage and code (#13535)

Author: hauntsaninja

mypy/checker.py

@@ -1218,7 +1218,6 @@ def check_func_def(self, defn: FuncItem, typ: CallableType, name: str | None) ->
                         supertype=return_type,
                         context=defn,
                         msg=message_registry.INCOMPATIBLE_RETURN_VALUE_TYPE,
-                        code=codes.RETURN_VALUE,
                     )
 
             self.return_types.pop()
@@ -4008,7 +4007,6 @@ def check_return_stmt(self, s: ReturnStmt) -> None:
                         context=s.expr,
                         outer_context=s,
                         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
@@ -5581,6 +5579,34 @@ def refine_away_none_in_comparison(
     #
     # Helpers
     #
+    @overload
+    def check_subtype(
+        self,
+        subtype: Type,
+        supertype: Type,
+        context: Context,
+        msg: str,
+        subtype_label: str | None = None,
+        supertype_label: str | None = None,
+        *,
+        code: ErrorCode | None = None,
+        outer_context: Context | None = None,
+    ) -> bool:
+        ...
+
+    @overload
+    def check_subtype(
+        self,
+        subtype: Type,
+        supertype: Type,
+        context: Context,
+        msg: ErrorMessage = message_registry.INCOMPATIBLE_TYPES,
+        subtype_label: str | None = None,
+        supertype_label: str | None = None,
+        *,
+        outer_context: Context | None = None,
+    ) -> bool:
+        ...
 
     def check_subtype(
         self,
@@ -5598,17 +5624,16 @@ def check_subtype(
         if is_subtype(subtype, supertype, options=self.options):
             return True
 
-        if isinstance(msg, ErrorMessage):
-            msg_text = msg.value
-            code = msg.code
-        else:
-            msg_text = msg
+        if isinstance(msg, str):
+            msg = ErrorMessage(msg, code=code)
+            del code
+
         orig_subtype = subtype
         subtype = get_proper_type(subtype)
         orig_supertype = supertype
         supertype = get_proper_type(supertype)
         if self.msg.try_report_long_tuple_assignment_error(
-            subtype, supertype, context, msg_text, subtype_label, supertype_label, code=code
+            subtype, supertype, context, msg, subtype_label, supertype_label
         ):
             return False
         extra_info: list[str] = []
@@ -5626,29 +5651,29 @@ def check_subtype(
             if isinstance(subtype, Instance) and isinstance(supertype, Instance):
                 notes = append_invariance_notes([], subtype, supertype)
         if extra_info:
-            msg_text += " (" + ", ".join(extra_info) + ")"
+            msg = msg.with_additional_msg(" (" + ", ".join(extra_info) + ")")
 
-        self.fail(ErrorMessage(msg_text, code=code), context)
+        self.fail(msg, context)
         for note in notes:
-            self.msg.note(note, context, code=code)
+            self.msg.note(note, context, code=msg.code)
         if note_msg:
-            self.note(note_msg, context, code=code)
-        self.msg.maybe_note_concatenate_pos_args(subtype, supertype, context, code=code)
+            self.note(note_msg, context, code=msg.code)
+        self.msg.maybe_note_concatenate_pos_args(subtype, supertype, context, code=msg.code)
         if (
             isinstance(supertype, Instance)
             and supertype.type.is_protocol
             and isinstance(subtype, (Instance, TupleType, TypedDictType))
         ):
-            self.msg.report_protocol_problems(subtype, supertype, context, code=code)
+            self.msg.report_protocol_problems(subtype, supertype, context, code=msg.code)
         if isinstance(supertype, CallableType) and isinstance(subtype, Instance):
             call = find_member("__call__", subtype, subtype, is_operator=True)
             if call:
-                self.msg.note_call(subtype, call, context, code=code)
+                self.msg.note_call(subtype, call, context, code=msg.code)
         if isinstance(subtype, (CallableType, Overloaded)) and isinstance(supertype, Instance):
             if supertype.type.is_protocol and supertype.type.protocol_members == ["__call__"]:
                 call = find_member("__call__", supertype, subtype, is_operator=True)
                 assert call is not None
-                self.msg.note_call(supertype, call, context, code=code)
+                self.msg.note_call(supertype, call, context, code=msg.code)
         self.check_possible_missing_await(subtype, supertype, context)
         return False
 

mypy/checkexpr.py

@@ -819,7 +819,7 @@ def check_typeddict_call_with_kwargs(
                     lvalue_type=item_expected_type,
                     rvalue=item_value,
                     context=item_value,
-                    msg=message_registry.INCOMPATIBLE_TYPES,
+                    msg=message_registry.INCOMPATIBLE_TYPES.value,
                     lvalue_name=f'TypedDict item "{item_name}"',
                     rvalue_name="expression",
                     code=codes.TYPEDDICT_ITEM,

mypy/message_registry.py

@@ -21,6 +21,9 @@ class ErrorMessage(NamedTuple):
     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 = "Invalid type: try using Literal[{}.{}] instead?"
@@ -47,7 +50,7 @@ def format(self, *args: object, **kwargs: object) -> ErrorMessage:
     "supertypes"
 )
 YIELD_VALUE_EXPECTED: Final = ErrorMessage("Yield value expected")
-INCOMPATIBLE_TYPES: Final = "Incompatible types"
+INCOMPATIBLE_TYPES: Final = ErrorMessage("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")

mypy/messages.py

@@ -2030,10 +2030,9 @@ def try_report_long_tuple_assignment_error(
         subtype: ProperType,
         supertype: ProperType,
         context: Context,
-        msg: str = message_registry.INCOMPATIBLE_TYPES,
+        msg: message_registry.ErrorMessage,
         subtype_label: str | None = None,
         supertype_label: str | None = None,
-        code: ErrorCode | None = None,
     ) -> bool:
         """Try to generate meaningful error message for very long tuple assignment
 
@@ -2048,26 +2047,25 @@ def try_report_long_tuple_assignment_error(
             ):
                 lhs_type = supertype.args[0]
                 lhs_types = [lhs_type] * len(subtype.items)
-                self.generate_incompatible_tuple_error(
-                    lhs_types, subtype.items, context, msg, code
-                )
+                self.generate_incompatible_tuple_error(lhs_types, subtype.items, context, msg)
                 return True
             elif isinstance(supertype, TupleType) and (
                 len(subtype.items) > 10 or len(supertype.items) > 10
             ):
                 if len(subtype.items) != len(supertype.items):
                     if supertype_label is not None and subtype_label is not None:
-                        error_msg = "{} ({} {}, {} {})".format(
-                            msg,
-                            subtype_label,
-                            self.format_long_tuple_type(subtype),
-                            supertype_label,
-                            self.format_long_tuple_type(supertype),
+                        msg = msg.with_additional_msg(
+                            " ({} {}, {} {})".format(
+                                subtype_label,
+                                self.format_long_tuple_type(subtype),
+                                supertype_label,
+                                self.format_long_tuple_type(supertype),
+                            )
                         )
-                        self.fail(error_msg, context, code=code)
+                        self.fail(msg.value, context, code=msg.code)
                         return True
                 self.generate_incompatible_tuple_error(
-                    supertype.items, subtype.items, context, msg, code
+                    supertype.items, subtype.items, context, msg
                 )
                 return True
         return False
@@ -2087,8 +2085,7 @@ def generate_incompatible_tuple_error(
         lhs_types: list[Type],
         rhs_types: list[Type],
         context: Context,
-        msg: str = message_registry.INCOMPATIBLE_TYPES,
-        code: ErrorCode | None = None,
+        msg: message_registry.ErrorMessage,
     ) -> None:
         """Generate error message for individual incompatible tuple pairs"""
         error_cnt = 0
@@ -2103,14 +2100,15 @@ def generate_incompatible_tuple_error(
                     )
                 error_cnt += 1
 
-        error_msg = msg + f" ({str(error_cnt)} tuple items are incompatible"
+        info = f" ({str(error_cnt)} tuple items are incompatible"
         if error_cnt - 3 > 0:
-            error_msg += f"; {str(error_cnt - 3)} items are omitted)"
+            info += f"; {str(error_cnt - 3)} items are omitted)"
         else:
-            error_msg += ")"
-        self.fail(error_msg, context, code=code)
+            info += ")"
+        msg = msg.with_additional_msg(info)
+        self.fail(msg.value, context, code=msg.code)
         for note in notes:
-            self.note(note, context, code=code)
+            self.note(note, context, code=msg.code)
 
     def add_fixture_note(self, fullname: str, ctx: Context) -> None:
         self.note(f'Maybe your test fixture does not define "{fullname}"?', ctx)