Merge branch 'master' into patch-2

BobTheBuidler · web-flow · commit 504586430363 · 2025-05-17T12:54:38.000-04:00
diff --git a/mypy/checker.py b/mypy/checker.py
@@ -437,12 +437,10 @@ def reset(self) -> None:
         self._type_maps[0].clear()
         self.temp_type_map = None
         self.expr_checker.reset()
-
-        assert self.inferred_attribute_types is None
-        assert self.partial_types == []
-        assert self.deferred_nodes == []
-        assert len(self.scope.stack) == 1
-        assert self.partial_types == []
+        self.deferred_nodes = []
+        self.partial_types = []
+        self.inferred_attribute_types = None
+        self.scope = CheckerScope(self.tree)
 
     def check_first_pass(self) -> None:
         """Type check the entire file, but defer functions with unresolved references.
@@ -1557,6 +1555,10 @@ def is_var_redefined_in_outer_context(self, v: Var, after_line: int) -> bool:
         Note that this doesn't do a full CFG analysis but uses a line number based
         heuristic that isn't correct in some (rare) cases.
         """
+        if v.is_final:
+            # Final vars are definitely never reassigned.
+            return False
+
         outers = self.tscope.outer_functions()
         if not outers:
             # Top-level function -- outer context is top level, and we can't reason about
diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py
@@ -2013,7 +2013,12 @@ def infer_function_type_arguments_using_context(
             #     variables in an expression are inferred at the same time.
             #     (And this is hard, also we need to be careful with lambdas that require
             #     two passes.)
-        if isinstance(ret_type, TypeVarType):
+        proper_ret = get_proper_type(ret_type)
+        if (
+            isinstance(proper_ret, TypeVarType)
+            or isinstance(proper_ret, UnionType)
+            and all(isinstance(get_proper_type(u), TypeVarType) for u in proper_ret.items)
+        ):
             # Another special case: the return type is a type variable. If it's unrestricted,
             # we could infer a too general type for the type variable if we use context,
             # and this could result in confusing and spurious type errors elsewhere.
diff --git a/mypy/dmypy/client.py b/mypy/dmypy/client.py
@@ -562,6 +562,10 @@ def check_output(
 
     Call sys.exit() unless the status code is zero.
     """
+    if os.name == "nt":
+        # Enable ANSI color codes for Windows cmd using this strange workaround
+        # ( see https://github.com/python/cpython/issues/74261 )
+        os.system("")
     if "error" in response:
         fail(response["error"])
     try:
diff --git a/mypy/main.py b/mypy/main.py
@@ -917,7 +917,7 @@ def add_invertible_flag(
     add_invertible_flag(
         "--strict-bytes",
         default=False,
-        strict_flag=False,
+        strict_flag=True,
         help="Disable treating bytearray and memoryview as subtypes of bytes",
         group=strictness_group,
     )
diff --git a/mypy/stubgen.py b/mypy/stubgen.py
@@ -565,7 +565,7 @@ def _get_func_args(self, o: FuncDef, ctx: FunctionContext) -> list[ArgSig]:
             default = "..."
             if arg_.initializer:
                 if not typename:
-                    typename = self.get_str_type_of_node(arg_.initializer, True, False)
+                    typename = self.get_str_type_of_node(arg_.initializer, can_be_incomplete=False)
                 potential_default, valid = self.get_str_default_of_node(arg_.initializer)
                 if valid and len(potential_default) <= 200:
                     default = potential_default
@@ -1305,9 +1305,7 @@ def is_private_member(self, fullname: str) -> bool:
         parts = fullname.split(".")
         return any(self.is_private_name(part) for part in parts)
 
-    def get_str_type_of_node(
-        self, rvalue: Expression, can_infer_optional: bool = False, can_be_any: bool = True
-    ) -> str:
+    def get_str_type_of_node(self, rvalue: Expression, *, can_be_incomplete: bool = True) -> str:
         rvalue = self.maybe_unwrap_unary_expr(rvalue)
 
         if isinstance(rvalue, IntExpr):
@@ -1327,9 +1325,7 @@ def get_str_type_of_node(
                 return "complex"
         if isinstance(rvalue, NameExpr) and rvalue.name in ("True", "False"):
             return "bool"
-        if can_infer_optional and isinstance(rvalue, NameExpr) and rvalue.name == "None":
-            return f"{self.add_name('_typeshed.Incomplete')} | None"
-        if can_be_any:
+        if can_be_incomplete:
             return self.add_name("_typeshed.Incomplete")
         else:
             return ""
diff --git a/mypy/stubgenc.py b/mypy/stubgenc.py
@@ -769,7 +769,11 @@ def get_type_fullname(self, typ: type) -> str:
             return "Any"
         typename = getattr(typ, "__qualname__", typ.__name__)
         module_name = self.get_obj_module(typ)
-        assert module_name is not None, typ
+        if module_name is None:
+            # This should not normally happen, but some types may resist our
+            # introspection attempts too hard. See
+            # https://github.com/python/mypy/issues/19031
+            return "_typeshed.Incomplete"
         if module_name != "builtins":
             typename = f"{module_name}.{typename}"
         return typename
diff --git a/mypy/stubtest.py b/mypy/stubtest.py
@@ -1494,6 +1494,7 @@ def verify_typealias(
         "__loader__",
         "__spec__",
         "__annotations__",
+        "__annotate__",
         "__path__",  # mypy adds __path__ to packages, but C packages don't have it
         "__getattr__",  # resulting behaviour might be typed explicitly
         # Created by `warnings.warn`, does not make much sense to have in stubs:
@@ -1510,6 +1511,9 @@ def verify_typealias(
         # Special attributes
         "__dict__",
         "__annotations__",
+        "__annotate__",
+        "__annotations_cache__",
+        "__annotate_func__",
         "__text_signature__",
         "__weakref__",
         "__hash__",
@@ -1518,6 +1522,7 @@ def verify_typealias(
         "__vectorcalloffset__",  # undocumented implementation detail of the vectorcall protocol
         "__firstlineno__",
         "__static_attributes__",
+        "__classdictcell__",
         # isinstance/issubclass hooks that type-checkers don't usually care about
         "__instancecheck__",
         "__subclasshook__",
@@ -1536,6 +1541,7 @@ def verify_typealias(
         "__getinitargs__",
         "__reduce_ex__",
         "__reduce__",
+        "__slotnames__",  # Cached names of slots added by `copyreg` module.
         # ctypes weirdness
         "__ctype_be__",
         "__ctype_le__",
diff --git a/mypy/typeshed/stdlib/tempfile.pyi b/mypy/typeshed/stdlib/tempfile.pyi
@@ -387,7 +387,7 @@ class SpooledTemporaryFile(IO[AnyStr], _SpooledTemporaryFileBase):
     def write(self: SpooledTemporaryFile[bytes], s: ReadableBuffer) -> int: ...
     @overload
     def write(self, s: AnyStr) -> int: ...
-    @overload
+    @overload  #  type: ignore[override]
     def writelines(self: SpooledTemporaryFile[str], iterable: Iterable[str]) -> None: ...
     @overload
     def writelines(self: SpooledTemporaryFile[bytes], iterable: Iterable[ReadableBuffer]) -> None: ...
diff --git a/mypy/typeshed/stdlib/tkinter/ttk.pyi b/mypy/typeshed/stdlib/tkinter/ttk.pyi
@@ -562,7 +562,7 @@ class Notebook(Widget):
         compound: tkinter._Compound = ...,
         underline: int = ...,
     ) -> None: ...
-    def forget(self, tab_id) -> None: ...
+    def forget(self, tab_id) -> None: ...  # type: ignore[override]
     def hide(self, tab_id) -> None: ...
     def identify(self, x: int, y: int) -> str: ...
     def index(self, tab_id): ...
diff --git a/mypy_self_check.ini b/mypy_self_check.ini
@@ -1,7 +1,6 @@
 [mypy]
 
 strict = True
-strict_bytes = True
 local_partial_types = True
 disallow_any_unimported = True
 show_traceback = True
diff --git a/test-data/unit/check-final.test b/test-data/unit/check-final.test
@@ -1250,3 +1250,25 @@ def check_final_init() -> None:
     new_instance = FinalInit()
     new_instance.__init__()
 [builtins fixtures/tuple.pyi]
+
+[case testNarrowingOfFinalPersistsInFunctions]
+from typing import Final, Union
+
+def _init() -> Union[int, None]:
+    return 0
+
+FOO: Final = _init()
+
+class Example:
+
+    if FOO is not None:
+        reveal_type(FOO)  # N: Revealed type is "builtins.int"
+
+        def fn(self) -> int:
+            return FOO
+
+if FOO is not None:
+    reveal_type(FOO)  # N: Revealed type is "builtins.int"
+
+    def func() -> int:
+        return FOO
diff --git a/test-data/unit/check-flags.test b/test-data/unit/check-flags.test
@@ -2408,6 +2408,23 @@ f(bytearray(b"asdf"))
 f(memoryview(b"asdf"))
 [builtins fixtures/primitives.pyi]
 
+[case testStrictBytesDisabledByDefault]
+# TODO: probably change this default in Mypy v2.0, with https://github.com/python/mypy/pull/18371
+# (this would also obsolete the testStrictBytesEnabledByStrict test, below)
+def f(x: bytes) -> None: ...
+f(bytearray(b"asdf"))
+f(memoryview(b"asdf"))
+[builtins fixtures/primitives.pyi]
+
+[case testStrictBytesEnabledByStrict]
+# flags: --strict --disable-error-code type-arg
+# The type-arg thing is just work around the primitives.pyi isinstance Tuple not having type parameters,
+#   which isn't important for this.
+def f(x: bytes) -> None: ...
+f(bytearray(b"asdf"))  # E: Argument 1 to "f" has incompatible type "bytearray"; expected "bytes"
+f(memoryview(b"asdf"))  # E: Argument 1 to "f" has incompatible type "memoryview"; expected "bytes"
+[builtins fixtures/primitives.pyi]
+
 [case testNoCrashFollowImportsForStubs]
 # flags: --config-file tmp/mypy.ini
 {**{"x": "y"}}
diff --git a/test-data/unit/check-inference-context.test b/test-data/unit/check-inference-context.test
@@ -1495,3 +1495,18 @@ def g(b: Optional[str]) -> None:
         z: Callable[[], str] = lambda: reveal_type(b)  # N: Revealed type is "builtins.str"
         f2(lambda: reveal_type(b))  # N: Revealed type is "builtins.str"
         lambda: reveal_type(b)  # N: Revealed type is "builtins.str"
+
+[case testInferenceContextReturningTypeVarUnion]
+from collections.abc import Callable, Iterable
+from typing import TypeVar, Union
+
+_T1 = TypeVar("_T1")
+_T2 = TypeVar("_T2")
+
+def mymin(
+    iterable: Iterable[_T1], /, *, key: Callable[[_T1], int], default: _T2
+) -> Union[_T1, _T2]: ...
+
+def check(paths: Iterable[str], key: Callable[[str], int]) -> Union[str, None]:
+    return mymin(paths, key=key, default=None)
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/stubgen.test b/test-data/unit/stubgen.test
@@ -30,12 +30,10 @@ def g(b=-1, c=0): ...
 def f(a, b: int = 2) -> None: ...
 def g(b: int = -1, c: int = 0) -> None: ...
 
-[case testDefaultArgNone]
+[case testFuncDefaultArgNone]
 def f(x=None): ...
 [out]
-from _typeshed import Incomplete
-
-def f(x: Incomplete | None = None) -> None: ...
+def f(x=None) -> None: ...
 
 [case testDefaultArgBool]
 def f(x=True, y=False): ...
@@ -1379,7 +1377,7 @@ async def f(a):
 [out]
 async def f(a) -> None: ...
 
-[case testInferOptionalOnlyFunc]
+[case testMethodDefaultArgNone]
 class A:
     x = None
     def __init__(self, a=None):
@@ -1391,8 +1389,8 @@ from _typeshed import Incomplete
 
 class A:
     x: Incomplete
-    def __init__(self, a: Incomplete | None = None) -> None: ...
-    def method(self, a: Incomplete | None = None) -> None: ...
+    def __init__(self, a=None) -> None: ...
+    def method(self, a=None) -> None: ...
 
 [case testAnnotationImportsFrom]
 import foo
@@ -2618,32 +2616,29 @@ class A(metaclass=abc.ABCMeta):
     @abc.abstractmethod
     def x(self): ...
 
-[case testClassWithNameIncompleteOrOptional]
+[case testClassWithNameIncomplete]
 Y = object()
 
-def g(x=None): pass
+def g():
+    yield 1
 
 x = g()
 
 class Incomplete:
     pass
 
-def Optional():
-    return 0
-
 [out]
 from _typeshed import Incomplete as _Incomplete
+from collections.abc import Generator
 
 Y: _Incomplete
 
-def g(x: _Incomplete | None = None) -> None: ...
+def g() -> Generator[_Incomplete]: ...
 
 x: _Incomplete
 
 class Incomplete: ...
 
-def Optional(): ...
-
 [case testExportedNameImported]
 # modules: main a b
 from a import C

Original file line number	Diff line number	Diff line change
`@@ -917,7 +917,7 @@ def add_invertible_flag(`
`917`	`917`	`add_invertible_flag(`
`918`	`918`	`"--strict-bytes",`
`919`	`919`	`default=False,`
`920`		`- strict_flag=False,`
	`920`	`+ strict_flag=True,`
`921`	`921`	`help="Disable treating bytearray and memoryview as subtypes of bytes",`
`922`	`922`	`group=strictness_group,`
`923`	`923`	`)`