func local

Author: grayjk

docs/source/command_line.rst

@@ -479,7 +479,7 @@ potentially problematic or redundant in some way.
 
 .. option:: --warn-redundant-annotation
 
-    This flag will make mypy report an error whenever your code uses
+    This flag will make mypy report an error when a function local variable uses
     an unnecessary annotation in an assignment that can safely be removed.
 
 .. option:: --warn-redundant-casts

docs/source/error_code_list2.rst

@@ -71,8 +71,8 @@ Example:
 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.
+If you use :option:`--warn-redundant-annotation <mypy --warn-redundant-annotation>`, mypy will generate an error if a
+function local annotation type is the same as the inferred type.
 
 Example:
 

mypy/checker.py

@@ -145,7 +145,6 @@
     WithStmt,
     YieldExpr,
     get_func_def,
-    is_class_var,
     is_final_node,
 )
 from mypy.operators import flip_ops, int_op_to_method, neg_ops
@@ -3270,20 +3269,9 @@ def check_redundant_annotation(self, s: AssignmentStmt) -> 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))
+            and (defn := self.scope.current_function()) is not None
+            and defn.name != "__init__"
         ):
-            # 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(

test-data/unit/check-warnings.test

@@ -78,19 +78,21 @@ a = 1
 b: int = a
 c: Literal[1] = 1
 d: list[str] = []
-[out]
-main:4: error: Annotation "int" is redundant (inferred type is the same)
-main:5: error: Annotation "Literal[1]" is redundant (inferred type is the same)
+def f() -> None:
+    a = 1
+    b: int = a  # E: Annotation "int" is redundant (inferred type is the same)
+    c: Literal[1] = 1  # E: Annotation "Literal[1]" is redundant (inferred type is the same)
+    d: list[str] = []
 
-[case testRedundantAnnotationClassVar]
-# flags: --warn-redundant-annotation
-from typing import ClassVar
+class x:
+    def __init__(self) -> None:
+        self.a: int = 1
 
-class a:
-    b: ClassVar[int] = 1
-    c: ClassVar = "test"
-[out]
-main:5: error: Annotation "int" is redundant (inferred type is the same)
+    def f(self) -> None:
+        a = 1
+        b: int = a  # E: Annotation "int" is redundant (inferred type is the same)
+        c: Literal[1] = 1  # E: Annotation "Literal[1]" is redundant (inferred type is the same)
+        d: list[str] = []
 
 [case testRedundantAnnotationTypeVar]
 # flags: --warn-redundant-annotation
@@ -101,13 +103,18 @@ T = TypeVar("T")
 def f(x: T) -> T:
   return x
 
-x: Literal[1] = f(1)
-y: list[str] = f([])
+def g() -> None:
+    x: Literal[1] = f(1)
+    y: list[str] = f([])
 
 [case testRedundantAnnotationSkips]
 # flags: --warn-redundant-annotation
 from dataclasses import dataclass
-from typing import NamedTuple
+from typing import ClassVar, NamedTuple
+
+class a:
+    b: ClassVar[int] = 1
+    c: ClassVar = "test"
 
 class d(NamedTuple):
     e: int = 1