Add redundant-annotation warning

docs/source/command_line.rst

@@ -477,6 +477,11 @@ Configuring warnings
 The following flags enable warnings for code that is sound but is
 potentially problematic or redundant in some way.
 
+.. option:: --warn-redundant-annotation
+
+    This flag will make mypy report an error whenever your code uses
+    an unnecessary annotation in an assignment that can safely be removed.
+
 .. option:: --warn-redundant-casts
 
     This flag will make mypy report an error whenever your code uses

docs/source/error_code_list2.rst

@@ -66,6 +66,23 @@ Example:
          def __init__(self) -> None:
              self.value = 0
 
+.. _code-redundant-annotation:
+
+Check that annotation is not redundant [redundant-annotation]
+-------------------------------------------------------------
+
+If you use :option:`--warn-redundant-annotation <mypy --warn-redundant-annotation>`, mypy will generate an error if the
+annotation type is the same as the inferred type.
+
+Example:
+
+.. code-block:: python
+
+    # mypy: warn-redundant-annotation
+
+    # Error: Annotation "int" is redundant  [redundant-annotation]
+    count: int = 4
+
 .. _code-redundant-cast:
 
 Check that cast is not redundant [redundant-cast]

mypy/checker.py

@@ -145,6 +145,7 @@
     WithStmt,
     YieldExpr,
     get_func_def,
+    is_class_var,
     is_final_node,
 )
 from mypy.operators import flip_ops, int_op_to_method, neg_ops
@@ -3206,6 +3207,8 @@ def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
         Handle all kinds of assignment statements (simple, indexed, multiple).
         """
 
+        self.check_redundant_annotation(s)
+
         # Avoid type checking type aliases in stubs to avoid false
         # positives about modern type syntax available in stubs such
         # as X | Y.
@@ -3258,6 +3261,31 @@ def check_type_alias_rvalue(self, s: AssignmentStmt) -> None:
             alias_type = self.expr_checker.accept(s.rvalue)
         self.store_type(s.lvalues[-1], alias_type)
 
+    def check_redundant_annotation(self, s: AssignmentStmt) -> None:
+        if (
+            self.options.warn_redundant_annotation
+            and not s.is_final_def
+            and not s.is_alias_def
+            and s.unanalyzed_type is not None
+            and s.type is not None
+            and not is_same_type(s.type, AnyType(TypeOfAny.special_form))
+            and is_same_type(s.type, self.expr_checker.accept(s.rvalue))
+        ):
+            # skip bare ClassVar
+            if (
+                any(isinstance(lvalue, NameExpr) and is_class_var(lvalue) for lvalue in s.lvalues)
+                and isinstance(s.unanalyzed_type, UnboundType)
+                and not s.unanalyzed_type.args
+            ):
+                return
+
+            # skip dataclass and NamedTuple
+            cls = self.scope.active_class()
+            if cls and (dataclasses_plugin.is_processed_dataclass(cls) or cls.is_named_tuple):
+                return
+
+            self.msg.redundant_annotation(s.type, s.type)
+
     def check_assignment(
         self,
         lvalue: Lvalue,

mypy/errorcodes.py

@@ -162,6 +162,9 @@ def __hash__(self) -> int:
     "Disallow calling functions without type annotations from annotated functions",
     "General",
 )
+REDUNDANT_ANNOTATION: Final = ErrorCode(
+    "redundant-annotation", "Check that the annotation is necessary or can be omitted", "General"
+)
 REDUNDANT_CAST: Final = ErrorCode(
     "redundant-cast", "Check that cast changes type of expression", "General"
 )

mypy/main.py

@@ -820,6 +820,13 @@ def add_invertible_flag(
         title="Configuring warnings",
         description="Detect code that is sound but redundant or problematic.",
     )
+    add_invertible_flag(
+        "--warn-redundant-annotation",
+        default=False,
+        strict_flag=False,
+        help="Warn when an annotation is the same as its inferred type",
+        group=lint_group,
+    )
     add_invertible_flag(
         "--warn-redundant-casts",
         default=False,

mypy/messages.py

@@ -1784,6 +1784,13 @@ def unsupported_type_type(self, item: Type, context: Context) -> None:
             f'Cannot instantiate type "type[{format_type_bare(item, self.options)}]"', context
         )
 
+    def redundant_annotation(self, typ: Type, context: Context) -> None:
+        self.fail(
+            f"Annotation {format_type(typ, self.options)} is redundant (inferred type is the same)",
+            context,
+            code=codes.REDUNDANT_ANNOTATION,
+        )
+
     def redundant_cast(self, typ: Type, context: Context) -> None:
         self.fail(
             f"Redundant cast to {format_type(typ, self.options)}",

mypy/options.py

@@ -175,6 +175,9 @@ def __init__(self) -> None:
         # Also check typeshed for missing annotations
         self.warn_incomplete_stub = False
 
+        # Warn when an annotation is the same as its inferred type
+        self.warn_redundant_annotation = False
+
         # Warn about casting an expression to its inferred type
         self.warn_redundant_casts = False
 

test-data/unit/check-warnings.test

@@ -68,6 +68,39 @@ z = Any
 def f(q: Union[x, y, z]) -> None:
     cast(Union[x, y], q)
 
+-- Redundant annotation
+-- --------------------
+
+[case testRedundantAnnotation]
+# flags: --warn-redundant-annotation
+a = 1
+b: int = a
+[out]
+main:3: error: Annotation "int" is redundant (inferred type is the same)
+
+[case testRedundantAnnotationClassVar]
+# flags: --warn-redundant-annotation
+from typing import ClassVar
+
+class a:
+    b: ClassVar[int] = 1
+    c: ClassVar = "test"
+[out]
+main:5: error: Annotation "int" is redundant (inferred type is the same)
+
+[case testRedundantAnnotationSkips]
+# flags: --warn-redundant-annotation
+from dataclasses import dataclass
+from typing import NamedTuple
+
+class d(NamedTuple):
+    e: int = 1
+
+@dataclass
+class f:
+    g: int = 1
+[builtins fixtures/tuple.pyi]
+
 -- Unused 'type: ignore' comments
 -- ------------------------------