Add redundant-annotation warning

Relates to #18540

Author: grayjk

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

@@ -3206,6 +3206,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 +3260,32 @@ 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 ClassVar
+            if any(
+                isinstance(lvalue, NameExpr)
+                and isinstance(lvalue.node, Var)
+                and lvalue.node.is_classvar
+                for lvalue in s.lvalues
+            ):
+                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.rvalue)
+
     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,33 @@ 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 testRedundantAnnotationSkips]
+# flags: --warn-redundant-annotation
+from dataclasses import dataclass
+from typing import ClassVar, NamedTuple
+
+class a:
+    b: ClassVar[int] = 1
+    c: ClassVar = 1
+
+class d(NamedTuple):
+    e: int = 1
+
+@dataclass
+class f:
+    g: int = 1
+[builtins fixtures/tuple.pyi]
+
 -- Unused 'type: ignore' comments
 -- ------------------------------