Enable strict optional for more test files (9)

mypy/test/testcheck.py

@@ -49,14 +49,6 @@
     typecheck_files.remove("check-modules-case.test")
 
 
-# TODO: Enable strict optional in test cases by default. Remove files here, once test cases are updated
-no_strict_optional_files = {
-    "check-modules.test",
-    "check-unions.test",
-    "check-varargs.test",
-}
-
-
 class TypeCheckSuite(DataSuite):
     files = typecheck_files
 
@@ -129,9 +121,7 @@ def run_case_once(
             perform_file_operations(operations)
 
         # Parse options after moving files (in case mypy.ini is being moved).
-        options = parse_options(
-            original_program_text, testcase, incremental_step, no_strict_optional_files
-        )
+        options = parse_options(original_program_text, testcase, incremental_step)
         options.use_builtins_fixtures = True
         if not testcase.name.endswith("_no_incomplete"):
             options.enable_incomplete_feature = [TYPE_VAR_TUPLE, UNPACK]

test-data/unit/check-modules.test

@@ -180,7 +180,8 @@ x = object()
 [case testChainedAssignmentAndImports]
 import m
 
-i, s = None, None # type: (int, str)
+i: int
+s: str
 if int():
     i = m.x
 if int():
@@ -585,6 +586,7 @@ x = 1+0
 
 
 [case testConditionalImportAndAssign]
+# flags: --no-strict-optional
 try:
     from m import x
 except:
@@ -676,6 +678,7 @@ class B(A): ...
 
 
 [case testImportVariableAndAssignNone]
+# flags: --no-strict-optional
 try:
     from m import x
 except:
@@ -684,6 +687,7 @@ except:
 x = 1
 
 [case testImportFunctionAndAssignNone]
+# flags: --no-strict-optional
 try:
     from m import f
 except:
@@ -709,6 +713,7 @@ except:
 def f(): pass
 
 [case testAssignToFuncDefViaGlobalDecl2]
+# flags: --no-strict-optional
 import typing
 from m import f
 def g() -> None:
@@ -721,6 +726,7 @@ def f(): pass
 [out]
 
 [case testAssignToFuncDefViaNestedModules]
+# flags: --no-strict-optional
 import m.n
 m.n.f = None
 m.n.f = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "Callable[[], Any]")
@@ -730,6 +736,7 @@ def f(): pass
 [out]
 
 [case testAssignToFuncDefViaModule]
+# flags: --no-strict-optional
 import m
 m.f = None
 m.f = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "Callable[[], Any]")
@@ -738,6 +745,7 @@ def f(): pass
 [out]
 
 [case testConditionalImportAndAssignNoneToModule]
+# flags: --no-strict-optional
 if object():
     import m
 else:
@@ -758,6 +766,7 @@ else:
 [out]
 
 [case testImportAndAssignToModule]
+# flags: --no-strict-optional
 import m
 m = None
 m.f(1) # E: Argument 1 to "f" has incompatible type "int"; expected "str"
@@ -930,8 +939,8 @@ tmp/a/b/__init__.py:3: error: Name "a" is not defined
 
 [case testSubmoduleMixingLocalAndQualifiedNames]
 from a.b import MyClass
-val1 = None  # type: a.b.MyClass  # E: Name "a" is not defined
-val2 = None  # type: MyClass
+val1: a.b.MyClass  # E: Name "a" is not defined
+val2: MyClass
 
 [file a/__init__.py]
 [file a/b.py]
@@ -1501,7 +1510,7 @@ import bar
 from foo import *
 def bar(y: AnyAlias) -> None:  pass
 
-l = None # type: ListAlias[int]
+l: ListAlias[int]
 reveal_type(l)
 
 [file foo.py]
@@ -1532,7 +1541,7 @@ Row = Dict[str, int]
 
 [case testImportStarAliasGeneric]
 from y import *
-notes = None  # type: G[X]
+notes: G[X]
 another = G[X]()
 second = XT[str]()
 last = XT[G]()
@@ -1561,7 +1570,7 @@ from typing import Any
 def bar(x: Any, y: AnyCallable) -> Any:
     return 'foo'
 
-cb = None # type: AnyCallable
+cb: AnyCallable
 reveal_type(cb) # N: Revealed type is "def (*Any, **Any) -> Any"
 
 [file foo.py]

test-data/unit/check-unions.test

@@ -55,12 +55,12 @@ class B: y = 2
 class C: pass
 class D: pass
 
-u = None # type: Union[A, C, D]
-v = None # type: Union[C, D]
-w = None # type: Union[A, B]
-x = None # type: Union[A, C]
-y = None # type: int
-z = None # type: str
+u: Union[A, C, D]
+v: Union[C, D]
+w: Union[A, B]
+x: Union[A, C]
+y: int
+z: str
 
 if int():
     y = w.y
@@ -89,9 +89,9 @@ class B:
 class C:
     def foo(self) -> str: pass
 
-x = None # type: Union[A, B]
-y = None # type: Union[A, C]
-i = None # type: int
+x: Union[A, B]
+y: Union[A, C]
+i: int
 
 x.foo()
 y.foo()
@@ -103,7 +103,7 @@ if int():
 
 [case testUnionIndexing]
 from typing import Union, List
-x = None # type: Union[List[int], str]
+x: Union[List[int], str]
 x[2]
 x[2] + 1 # E: Unsupported operand types for + ("str" and "int") \
          # N: Left operand is of type "Union[int, str]"
@@ -132,6 +132,7 @@ def f(x: Union[int, str]) -> int: pass
 def f(x: type) -> str: pass
 
 [case testUnionWithNoneItem]
+# flags: --no-strict-optional
 from typing import Union
 def f() -> Union[int, None]: pass
 x = 1
@@ -221,6 +222,7 @@ else:
                                              # N:     def g(x: Union[int, str]) -> None
 
 [case testUnionSimplificationSpecialCases]
+# flags: --no-strict-optional
 from typing import Any, TypeVar, Union
 
 class C(Any): pass
@@ -266,9 +268,10 @@ class M(Generic[V]):
 
 def f(x: M[C]) -> None:
     y = x.get(None)
-    reveal_type(y) # N: Revealed type is "__main__.C"
+    reveal_type(y) # N: Revealed type is "Union[__main__.C, None]"
 
 [case testUnionSimplificationSpecialCases2]
+# flags: --no-strict-optional
 from typing import Any, TypeVar, Union
 
 class C(Any): pass
@@ -317,10 +320,10 @@ S = TypeVar('S')
 R = TypeVar('R')
 def u(x: T, y: S, z: R) -> Union[R, S, T]: pass
 
-a = None # type: Any
+a: Any
 
 reveal_type(u(1, 1, 1))  # N: Revealed type is "builtins.int"
-reveal_type(u(C(), C(), None))  # N: Revealed type is "__main__.C"
+reveal_type(u(C(), C(), None))  # N: Revealed type is "Union[None, __main__.C]"
 reveal_type(u(a, a, 1))  # N: Revealed type is "Union[builtins.int, Any]"
 reveal_type(u(a, C(), a))  # N: Revealed type is "Union[Any, __main__.C]"
 reveal_type(u('', 1, 1))  # N: Revealed type is "Union[builtins.int, builtins.str]"
@@ -370,9 +373,9 @@ T = TypeVar('T')
 S = TypeVar('S')
 def u(x: T, y: S) -> Union[S, T]: pass
 
-t_o = None  # type: Type[object]
-t_s = None  # type: Type[str]
-t_a = None  # type: Type[Any]
+t_o: Type[object]
+t_s: Type[str]
+t_a: Type[Any]
 
 # Two identical items
 reveal_type(u(t_o, t_o)) # N: Revealed type is "Type[builtins.object]"
@@ -397,10 +400,10 @@ T = TypeVar('T')
 S = TypeVar('S')
 def u(x: T, y: S) -> Union[S, T]: pass
 
-t_o = None  # type: Type[object]
-t_s = None  # type: Type[str]
-t_a = None  # type: Type[Any]
-t = None    # type: type
+t_o: Type[object]
+t_s: Type[str]
+t_a: Type[Any]
+t: type
 
 # Union with object
 reveal_type(u(t_o, object())) # N: Revealed type is "builtins.object"
@@ -1010,6 +1013,7 @@ MYTYPE = List[Union[str, "MYTYPE"]] # E: Cannot resolve name "MYTYPE" (possible
 [builtins fixtures/list.pyi]
 
 [case testNonStrictOptional]
+# flags: --no-strict-optional
 from typing import Optional, List
 
 def union_test1(x):