Migrate remaining failure messages to mypy.messages_registry (ircheck.py)

docs/source/config_file.rst

@@ -366,7 +366,7 @@ section of the command line docs.
 
 .. confval:: no_site_packages
 
-    :type: boolean
+    :type: bool
     :default: False
 
     Disables using type information in installed packages (see :pep:`561`).

mypy/message_registry.py

@@ -29,6 +29,12 @@ def with_additional_msg(self, info: str) -> ErrorMessage:
 INVALID_TYPE_RAW_ENUM_VALUE: Final = ErrorMessage(
     "Invalid type: try using Literal[{}.{}] instead?", codes.VALID_TYPE
 )
+INVALID_TYPE_FROZENSET_LITERAL: Final = ErrorMessage(
+    "Invalid type for item of frozenset literal: {})"
+)
+INVALID_TYPE_TUPLE_LITERAL: Final = ErrorMessage("Invalid type for item of tuple literal: {}}")
+FLOAT_NOT_EXPECTED: Final = ErrorMessage("Float not expected")
+FLOAT_EXPECTED: Final = ErrorMessage("Float expected (actual type is {})")
 
 # Type checker error message constants
 NO_RETURN_VALUE_EXPECTED: Final = ErrorMessage("No return value expected", codes.RETURN_VALUE)
@@ -162,6 +168,13 @@ def with_additional_msg(self, info: str) -> ErrorMessage:
 )
 NOT_CALLABLE: Final = "{} not callable"
 TYPE_MUST_BE_USED: Final = "Value of type {} must be used"
+TYPES_NOT_COMPATIBLE: Final = ErrorMessage("{} and {} are not compatible")
+CANNOT_COERSE_SRC_DEST: Final = ErrorMessage("Cannot coerce source type {} to dest type {}")
+INVALID_CONTROL_OPERATION_TARGET: Final = ErrorMessage("Invalid control operation target: {}")
+INCORRECT_NUMBER_ARGS: Final = ErrorMessage("Incorrect number of args for method call.")
+INVALID_LITERAL_VALUE_TYPE: Final = ErrorMessage(
+    "Invalid literal value for type: value has type {}, but op has type {}"
+)
 
 # Generic
 GENERIC_INSTANCE_VAR_CLASS_ACCESS: Final = (
@@ -316,3 +329,25 @@ def with_additional_msg(self, info: str) -> ErrorMessage:
 ARG_NAME_EXPECTED_STRING_LITERAL: Final = ErrorMessage(
     "Expected string literal for argument name, got {}", codes.SYNTAX
 )
+# Semanal newtype
+NEWTYPE_PROTOCOL_CLASSES: Final = ErrorMessage("NewType cannot be used with protocol classes")
+ARG_1_NEWTYPE_LITERAL: Final = ErrorMessage("Argument 1 to NewType(...) must be a string literal")
+ARG_2_NEWTYPE_SUBCLASSABLE: Final = ErrorMessage(
+    "Argument 2 to NewType(...) must be subclassable (got {})"
+)
+ARG_2_NEWTYPE_INVALID_TYPE: Final = ErrorMessage("Argument 2 to NewType(...) must be a valid type")
+CANNOT_DECLARE_TYPE: Final = ErrorMessage("Cannot declare the type of a NewType declaration")
+CANNOT_REDEFINE_NEWTYPE: Final = ErrorMessage("Cannot redefine {} as a NewType")
+EXCEPT_TWO_POSITIONAL_ARGS: Final = ErrorMessage(
+    "NewType(...) expects exactly two positional arguments"
+)
+MATCH_ERROR_STR_ARG1_VAR_NAME: Final = ErrorMessage(
+    "String argument 1 {} to NewType(...) does not match variable name {}"
+)
+# Blocks
+BLOCK_NOT_TERMINATED: Final = ErrorMessage("Block not terminated")
+OPERATIONS_AFTER_CONTROL: Final = ErrorMessage("Block has operations after control op")
+# Op
+FUNC_DUPLICATE_OP: Final = ErrorMessage("Func has a duplicate op")
+INVALID_OP_REFERENCE_TYPE: Final = ErrorMessage("Invalid op reference to op of type {}")
+INVALID_OP_REFERENCE_REGISTER: Final = ErrorMessage("Invalid op reference to register {}")

mypy/semanal.py

@@ -2189,10 +2189,6 @@ def configure_base_classes(
         if not self.verify_base_classes(defn):
             self.set_dummy_mro(defn.info)
             return
-        if not self.verify_duplicate_base_classes(defn):
-            # We don't want to block the typechecking process,
-            # so, we just insert `Any` as the base class and show an error.
-            self.set_any_mro(defn.info)
         self.calculate_class_mro(defn, self.object_type)
 
     def configure_tuple_base_class(self, defn: ClassDef, base: TupleType) -> Instance:
@@ -2222,11 +2218,6 @@ def set_dummy_mro(self, info: TypeInfo) -> None:
         info.mro = [info, self.object_type().type]
         info.bad_mro = True
 
-    def set_any_mro(self, info: TypeInfo) -> None:
-        # Give it an MRO consisting direct `Any` subclass.
-        info.fallback_to_any = True
-        info.mro = [info, self.object_type().type]
-
     def calculate_class_mro(
         self, defn: ClassDef, obj_type: Callable[[], Instance] | None = None
     ) -> None:
@@ -2307,13 +2298,11 @@ def verify_base_classes(self, defn: ClassDef) -> bool:
             if self.is_base_class(info, baseinfo):
                 self.fail("Cycle in inheritance hierarchy", defn)
                 cycle = True
-        return not cycle
-
-    def verify_duplicate_base_classes(self, defn: ClassDef) -> bool:
-        dup = find_duplicate(defn.info.direct_base_classes())
+        dup = find_duplicate(info.direct_base_classes())
         if dup:
-            self.fail(f'Duplicate base class "{dup.name}"', defn)
-        return not dup
+            self.fail(f'Duplicate base class "{dup.name}"', defn, blocker=True)
+            return False
+        return not cycle
 
     def is_base_class(self, t: TypeInfo, s: TypeInfo) -> bool:
         """Determine if t is a base class of s (but do not use mro)."""

mypyc/analysis/ircheck.py

@@ -1,6 +1,8 @@
 """Utilities for checking that internal ir is valid and consistent."""
 from __future__ import annotations
 
+from mypy import message_registry
+from mypy.message_registry import ErrorMessage
 from mypyc.ir.func_ir import FUNC_STATICMETHOD, FuncIR
 from mypyc.ir.ops import (
     Assign,
@@ -69,7 +71,7 @@
 
 
 class FnError:
-    def __init__(self, source: Op | BasicBlock, desc: str) -> None:
+    def __init__(self, source: Op | BasicBlock, desc: ErrorMessage) -> None:
         self.source = source
         self.desc = desc
 
@@ -91,14 +93,17 @@ def check_func_ir(fn: FuncIR) -> list[FnError]:
     for block in fn.blocks:
         if not block.terminated:
             errors.append(
-                FnError(source=block.ops[-1] if block.ops else block, desc="Block not terminated")
+                FnError(
+                    source=block.ops[-1] if block.ops else block,
+                    desc=message_registry.BLOCK_NOT_TERMINATED,
+                )
             )
         for op in block.ops[:-1]:
             if isinstance(op, ControlOp):
-                errors.append(FnError(source=op, desc="Block has operations after control op"))
+                errors.append(FnError(source=op, desc=message_registry.OPERATIONS_AFTER_CONTROL))
 
             if op in op_set:
-                errors.append(FnError(source=op, desc="Func has a duplicate op"))
+                errors.append(FnError(source=op, desc=message_registry.FUNC_DUPLICATE_OP))
             op_set.add(op)
 
     errors.extend(check_op_sources_valid(fn))
@@ -122,7 +127,7 @@ def assert_func_ir_valid(fn: FuncIR) -> None:
     if errors:
         raise IrCheckException(
             "Internal error: Generated invalid IR: \n"
-            + "\n".join(format_func(fn, [(e.source, e.desc) for e in errors]))
+            + "\n".join(format_func(fn, [(e.source, e.desc.value) for e in errors]))
         )
 
 
@@ -152,14 +157,19 @@ def check_op_sources_valid(fn: FuncIR) -> list[FnError]:
                         errors.append(
                             FnError(
                                 source=op,
-                                desc=f"Invalid op reference to op of type {type(source).__name__}",
+                                desc=message_registry.INVALID_OP_REFERENCE_TYPE.format(
+                                    type(source).__name__
+                                ),
                             )
                         )
                 elif isinstance(source, Register):
                     if source not in valid_registers:
                         errors.append(
                             FnError(
-                                source=op, desc=f"Invalid op reference to register {source.name!r}"
+                                source=op,
+                                desc=message_registry.INVALID_OP_REFERENCE_REGISTER.format(
+                                    source.name
+                                ),
                             )
                         )
 
@@ -208,31 +218,31 @@ def __init__(self, parent_fn: FuncIR) -> None:
         self.parent_fn = parent_fn
         self.errors: list[FnError] = []
 
-    def fail(self, source: Op, desc: str) -> None:
+    def fail(self, source: Op, desc: ErrorMessage) -> None:
         self.errors.append(FnError(source=source, desc=desc))
 
     def check_control_op_targets(self, op: ControlOp) -> None:
         for target in op.targets():
             if target not in self.parent_fn.blocks:
-                self.fail(source=op, desc=f"Invalid control operation target: {target.label}")
+                self.fail(
+                    op, message_registry.INVALID_CONTROL_OPERATION_TARGET.format(target.label)
+                )
 
     def check_type_coercion(self, op: Op, src: RType, dest: RType) -> None:
         if not can_coerce_to(src, dest):
-            self.fail(
-                source=op, desc=f"Cannot coerce source type {src.name} to dest type {dest.name}"
-            )
+            self.fail(op, message_registry.CANNOT_COERSE_SRC_DEST.format(src.name, dest.name))
 
     def check_compatibility(self, op: Op, t: RType, s: RType) -> None:
         if not can_coerce_to(t, s) or not can_coerce_to(s, t):
-            self.fail(source=op, desc=f"{t.name} and {s.name} are not compatible")
+            self.fail(op, message_registry.TYPES_NOT_COMPATIBLE.format(t.name, s.name))
 
     def expect_float(self, op: Op, v: Value) -> None:
         if not is_float_rprimitive(v.type):
-            self.fail(op, f"Float expected (actual type is {v.type})")
+            self.fail(op, message_registry.FLOAT_EXPECTED.format(v.type))
 
     def expect_non_float(self, op: Op, v: Value) -> None:
         if is_float_rprimitive(v.type):
-            self.fail(op, "Float not expected")
+            self.fail(op, message_registry.FLOAT_NOT_EXPECTED)
 
     def visit_goto(self, op: Goto) -> None:
         self.check_control_op_targets(op)
@@ -265,7 +275,7 @@ def visit_load_error_value(self, op: LoadErrorValue) -> None:
     def check_tuple_items_valid_literals(self, op: LoadLiteral, t: tuple[object, ...]) -> None:
         for x in t:
             if x is not None and not isinstance(x, (str, bytes, bool, int, float, complex, tuple)):
-                self.fail(op, f"Invalid type for item of tuple literal: {type(x)})")
+                self.fail(op, message_registry.INVALID_TYPE_TUPLE_LITERAL.format(type(x)))
             if isinstance(x, tuple):
                 self.check_tuple_items_valid_literals(op, x)
 
@@ -276,7 +286,7 @@ def check_frozenset_items_valid_literals(self, op: LoadLiteral, s: frozenset[obj
             elif isinstance(x, tuple):
                 self.check_tuple_items_valid_literals(op, x)
             else:
-                self.fail(op, f"Invalid type for item of frozenset literal: {type(x)})")
+                self.fail(op, message_registry.INVALID_TYPE_FROZENSET_LITERAL.format(type(x)))
 
     def visit_load_literal(self, op: LoadLiteral) -> None:
         expected_type = None
@@ -307,9 +317,7 @@ def visit_load_literal(self, op: LoadLiteral) -> None:
 
         if op.type.name not in [expected_type, "builtins.object"]:
             self.fail(
-                op,
-                f"Invalid literal value for type: value has "
-                f"type {expected_type}, but op has type {op.type.name}",
+                op, message_registry.INVALID_LITERAL_VALUE_TYPE.format(expected_type, op.type.name)
             )
 
     def visit_get_attr(self, op: GetAttr) -> None:
@@ -358,7 +366,7 @@ def visit_method_call(self, op: MethodCall) -> None:
             decl_index = 1
 
         if len(op.args) + decl_index != len(method_decl.sig.args):
-            self.fail(op, "Incorrect number of args for method call.")
+            self.fail(op, message_registry.INCORRECT_NUMBER_ARGS)
 
         # Skip the receiver argument (self)
         for arg_value, arg_runtime in zip(op.args, method_decl.sig.args[decl_index:]):

mypyc/codegen/emitfunc.py

@@ -775,8 +775,6 @@ def reg(self, reg: Value) -> str:
                 return "INFINITY"
             elif r == "-inf":
                 return "-INFINITY"
-            elif r == "nan":
-                return "NAN"
             return r
         else:
             return self.emitter.reg(reg)

mypyc/codegen/literals.py

@@ -265,8 +265,6 @@ def float_to_c(x: float) -> str:
         return "INFINITY"
     elif s == "-inf":
         return "-INFINITY"
-    elif s == "nan":
-        return "NAN"
     return s
 
 

mypyc/irbuild/builder.py

@@ -48,7 +48,6 @@
 )
 from mypy.types import (
     AnyType,
-    DeletedType,
     Instance,
     ProperType,
     TupleType,
@@ -302,9 +301,6 @@ def load_bytes_from_str_literal(self, value: str) -> Value:
     def load_int(self, value: int) -> Value:
         return self.builder.load_int(value)
 
-    def load_float(self, value: float) -> Value:
-        return self.builder.load_float(value)
-
     def unary_op(self, lreg: Value, expr_op: str, line: int) -> Value:
         return self.builder.unary_op(lreg, expr_op, line)
 
@@ -574,22 +570,21 @@ def get_assignment_target(
                 self.error("Cannot assign to the first argument of classmethod", line)
             if lvalue.kind == LDEF:
                 if symbol not in self.symtables[-1]:
-                    if isinstance(symbol, Var) and not isinstance(symbol.type, DeletedType):
-                        reg_type = self.type_to_rtype(symbol.type)
-                    else:
-                        reg_type = self.node_type(lvalue)
                     # If the function is a generator function, then first define a new variable
                     # in the current function's environment class. Next, define a target that
                     # refers to the newly defined variable in that environment class. Add the
                     # target to the table containing class environment variables, as well as the
                     # current environment.
                     if self.fn_info.is_generator:
                         return self.add_var_to_env_class(
-                            symbol, reg_type, self.fn_info.generator_class, reassign=False
+                            symbol,
+                            self.node_type(lvalue),
+                            self.fn_info.generator_class,
+                            reassign=False,
                         )
 
                     # Otherwise define a new local variable.
-                    return self.add_local_reg(symbol, reg_type)
+                    return self.add_local_reg(symbol, self.node_type(lvalue))
                 else:
                     # Assign to a previously defined variable.
                     return self.lookup(symbol)

mypyc/irbuild/expression.py

@@ -6,7 +6,6 @@
 
 from __future__ import annotations
 
-import math
 from typing import Callable, Sequence
 
 from mypy.nodes import (
@@ -129,10 +128,6 @@ def transform_name_expr(builder: IRBuilder, expr: NameExpr) -> Value:
     if fullname == "builtins.False":
         return builder.false()
 
-    math_literal = transform_math_literal(builder, fullname)
-    if math_literal is not None:
-        return math_literal
-
     if isinstance(expr.node, Var) and expr.node.is_final:
         value = builder.emit_load_final(
             expr.node,
@@ -197,10 +192,6 @@ def transform_member_expr(builder: IRBuilder, expr: MemberExpr) -> Value:
         if value is not None:
             return value
 
-    math_literal = transform_math_literal(builder, expr.fullname)
-    if math_literal is not None:
-        return math_literal
-
     if isinstance(expr.node, MypyFile) and expr.node.fullname in builder.imports:
         return builder.load_module(expr.node.fullname)
 
@@ -1052,18 +1043,3 @@ def transform_assignment_expr(builder: IRBuilder, o: AssignmentExpr) -> Value:
     target = builder.get_assignment_target(o.target)
     builder.assign(target, value, o.line)
     return value
-
-
-def transform_math_literal(builder: IRBuilder, fullname: str) -> Value | None:
-    if fullname == "math.e":
-        return builder.load_float(math.e)
-    if fullname == "math.pi":
-        return builder.load_float(math.pi)
-    if fullname == "math.inf":
-        return builder.load_float(math.inf)
-    if fullname == "math.nan":
-        return builder.load_float(math.nan)
-    if fullname == "math.tau":
-        return builder.load_float(math.tau)
-
-    return None