Merge branch 'master' into master

Author: yangdanny97

.pre-commit-config.yaml

@@ -1,17 +1,17 @@
 exclude: '^(mypyc/external/)|(mypy/typeshed/)|misc/typeshed_patches'  # Exclude all vendored code from lints
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.5.0  # must match test-requirements.txt
+    rev: v4.5.0
     hooks:
       - id: trailing-whitespace
       - id: end-of-file-fixer
   - repo: https://github.com/psf/black-pre-commit-mirror
-    rev: 24.8.0  # must match test-requirements.txt
+    rev: 24.8.0
     hooks:
       - id: black
         exclude: '^(test-data/)'
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.6.9  # must match test-requirements.txt
+    rev: v0.6.9
     hooks:
       - id: ruff
         args: [--exit-non-zero-on-fix]

mypy/checker.py

@@ -2367,10 +2367,11 @@ def erase_override(t: Type) -> Type:
                     else:
                         continue
                     if not is_subtype(original_arg_type, erase_override(override_arg_type)):
+                        context: Context = node
                         if isinstance(node, FuncDef) and not node.is_property:
-                            context: Context = node.arguments[i + len(override.bound_args)]
-                        else:
-                            context = node
+                            arg_node = node.arguments[i + len(override.bound_args)]
+                            if arg_node.line != -1:
+                                context = arg_node
                         self.msg.argument_incompatible_with_supertype(
                             i + 1,
                             name,

mypy/checkpattern.py

@@ -158,7 +158,8 @@ def visit_or_pattern(self, o: OrPattern) -> PatternType:
         for pattern in o.patterns:
             pattern_type = self.accept(pattern, current_type)
             pattern_types.append(pattern_type)
-            current_type = pattern_type.rest_type
+            if not is_uninhabited(pattern_type.type):
+                current_type = pattern_type.rest_type
 
         #
         # Collect the final type
@@ -693,7 +694,9 @@ def visit_class_pattern(self, o: ClassPattern) -> PatternType:
 
     def should_self_match(self, typ: Type) -> bool:
         typ = get_proper_type(typ)
-        if isinstance(typ, Instance) and typ.type.is_named_tuple:
+        if isinstance(typ, Instance) and typ.type.get("__match_args__") is not None:
+            # Named tuples and other subtypes of builtins that define __match_args__
+            # should not self match.
             return False
         for other in self.self_match_types:
             if is_subtype(typ, other):

mypy/nodes.py

@@ -1727,7 +1727,7 @@ def accept(self, visitor: ExpressionVisitor[T]) -> T:
         return visitor.visit_str_expr(self)
 
 
-def is_StrExpr_list(seq: list[Expression]) -> TypeGuard[list[StrExpr]]:
+def is_StrExpr_list(seq: list[Expression]) -> TypeGuard[list[StrExpr]]:  # noqa: N802
     return all(isinstance(item, StrExpr) for item in seq)
 
 

mypy/stubutil.py

@@ -832,6 +832,8 @@ def is_not_in_all(self, name: str) -> bool:
         return False
 
     def is_private_name(self, name: str, fullname: str | None = None) -> bool:
+        if "__mypy-" in name:
+            return True  # Never include mypy generated symbols
         if self._include_private:
             return False
         if fullname in self.EXTRA_EXPORTED:

mypy/test/data.py

@@ -304,7 +304,7 @@ def __init__(
         self.data = data
         self.line = line
         self.old_cwd: str | None = None
-        self.tmpdir: tempfile.TemporaryDirectory[str] | None = None
+        self.tmpdir: str | None = None
 
     def runtest(self) -> None:
         if self.skip:
@@ -323,19 +323,19 @@ def runtest(self) -> None:
             save_dir: str | None = self.config.getoption("--save-failures-to", None)
             if save_dir:
                 assert self.tmpdir is not None
-                target_dir = os.path.join(save_dir, os.path.basename(self.tmpdir.name))
+                target_dir = os.path.join(save_dir, os.path.basename(self.tmpdir))
                 print(f"Copying data from test {self.name} to {target_dir}")
                 if not os.path.isabs(target_dir):
                     assert self.old_cwd
                     target_dir = os.path.join(self.old_cwd, target_dir)
-                shutil.copytree(self.tmpdir.name, target_dir)
+                shutil.copytree(self.tmpdir, target_dir)
             raise
 
     def setup(self) -> None:
         parse_test_case(case=self)
         self.old_cwd = os.getcwd()
-        self.tmpdir = tempfile.TemporaryDirectory(prefix="mypy-test-")
-        os.chdir(self.tmpdir.name)
+        self.tmpdir = tempfile.mkdtemp(prefix="mypy-test-")
+        os.chdir(self.tmpdir)
         os.mkdir(test_temp_dir)
 
         # Precalculate steps for find_steps()
@@ -371,10 +371,7 @@ def teardown(self) -> None:
         if self.old_cwd is not None:
             os.chdir(self.old_cwd)
         if self.tmpdir is not None:
-            try:
-                self.tmpdir.cleanup()
-            except OSError:
-                pass
+            shutil.rmtree(self.tmpdir, ignore_errors=True)
         self.old_cwd = None
         self.tmpdir = None
 

mypy/test/testfinegrained.py

@@ -101,8 +101,8 @@ def run_case(self, testcase: DataDrivenTestCase) -> None:
         if messages:
             a.extend(normalize_messages(messages))
 
-        assert testcase.tmpdir
-        a.extend(self.maybe_suggest(step, server, main_src, testcase.tmpdir.name))
+        assert testcase.tmpdir is not None
+        a.extend(self.maybe_suggest(step, server, main_src, testcase.tmpdir))
         a.extend(self.maybe_inspect(step, server, main_src))
 
         if server.fine_grained_manager:
@@ -248,8 +248,8 @@ def perform_step(
         new_messages = normalize_messages(new_messages)
 
         a = new_messages
-        assert testcase.tmpdir
-        a.extend(self.maybe_suggest(step, server, main_src, testcase.tmpdir.name))
+        assert testcase.tmpdir is not None
+        a.extend(self.maybe_suggest(step, server, main_src, testcase.tmpdir))
         a.extend(self.maybe_inspect(step, server, main_src))
 
         return a, triggered

mypy/test/teststubgen.py

@@ -987,7 +987,7 @@ def test(cls, arg0: str) -> None:
     def test_generate_c_type_classmethod_with_overloads(self) -> None:
         class TestClass:
             @classmethod
-            def test(self, arg0: str) -> None:
+            def test(cls, arg0: str) -> None:
                 """
                 test(cls, arg0: str)
                 test(cls, arg0: int)

mypy/typeops.py

@@ -650,8 +650,16 @@ def _remove_redundant_union_items(items: list[Type], keep_erased: bool) -> list[
 def _get_type_method_ret_type(t: Type, *, name: str) -> Type | None:
     t = get_proper_type(t)
 
+    # For Enum literals the ret_type can change based on the Enum
+    # we need to check the type of the enum rather than the literal
+    if isinstance(t, LiteralType) and t.is_enum_literal():
+        t = t.fallback
+
     if isinstance(t, Instance):
         sym = t.type.get(name)
+        # Fallback to the metaclass for the lookup when necessary
+        if not sym and (m := t.type.metaclass_type):
+            sym = m.type.get(name)
         if sym:
             sym_type = get_proper_type(sym.type)
             if isinstance(sym_type, CallableType):

mypy/types.py

@@ -2818,10 +2818,28 @@ def __init__(
         self.fallback = fallback
         self._hash = -1  # Cached hash value
 
+    # NOTE: Enum types are always truthy by default, but this can be changed
+    #       in subclasses, so we need to get the truthyness from the Enum
+    #       type rather than base it on the value (which is a non-empty
+    #       string for enums, so always truthy)
+    # TODO: We should consider moving this branch to the `can_be_true`
+    #       `can_be_false` properties instead, so the truthyness only
+    #       needs to be determined once per set of Enum literals.
+    #       However, the same can be said for `TypeAliasType` in some
+    #       cases and we only set the default based on the type it is
+    #       aliasing. So if we decide to change this, we may want to
+    #       change that as well. perf_compare output was inconclusive
+    #       but slightly favored this version, probably because we have
+    #       almost no test cases where we would redundantly compute
+    #       `can_be_false`/`can_be_true`.
     def can_be_false_default(self) -> bool:
+        if self.fallback.type.is_enum:
+            return self.fallback.can_be_false
         return not self.value
 
     def can_be_true_default(self) -> bool:
+        if self.fallback.type.is_enum:
+            return self.fallback.can_be_true
         return bool(self.value)
 
     def accept(self, visitor: TypeVisitor[T]) -> T: