Merge branch 'master' into to-bytes

Author: BobTheBuidler

docs/requirements-docs.txt

@@ -1,3 +1,4 @@
+-r ../mypy-requirements.txt
 sphinx>=8.1.0
 furo>=2022.3.4
 myst-parser>=4.0.0

mypy/cache.py

@@ -3,17 +3,21 @@
 from collections.abc import Sequence
 from typing import TYPE_CHECKING, Final
 
+from mypy_extensions import u8
+
 try:
     from native_internal import (
         Buffer as Buffer,
         read_bool as read_bool,
         read_float as read_float,
         read_int as read_int,
         read_str as read_str,
+        read_tag as read_tag,
         write_bool as write_bool,
         write_float as write_float,
         write_int as write_int,
         write_str as write_str,
+        write_tag as write_tag,
     )
 except ImportError:
     # TODO: temporary, remove this after we publish mypy-native on PyPI.
@@ -32,6 +36,12 @@ def read_int(data: Buffer) -> int:
         def write_int(data: Buffer, value: int) -> None:
             raise NotImplementedError
 
+        def read_tag(data: Buffer) -> u8:
+            raise NotImplementedError
+
+        def write_tag(data: Buffer, value: u8) -> None:
+            raise NotImplementedError
+
         def read_str(data: Buffer) -> str:
             raise NotImplementedError
 
@@ -51,45 +61,48 @@ def write_float(data: Buffer, value: float) -> None:
             raise NotImplementedError
 
 
-LITERAL_INT: Final = 1
-LITERAL_STR: Final = 2
-LITERAL_BOOL: Final = 3
-LITERAL_FLOAT: Final = 4
-LITERAL_COMPLEX: Final = 5
-LITERAL_NONE: Final = 6
+# Always use this type alias to refer to type tags.
+Tag = u8
+
+LITERAL_INT: Final[Tag] = 1
+LITERAL_STR: Final[Tag] = 2
+LITERAL_BOOL: Final[Tag] = 3
+LITERAL_FLOAT: Final[Tag] = 4
+LITERAL_COMPLEX: Final[Tag] = 5
+LITERAL_NONE: Final[Tag] = 6
 
 
-def read_literal(data: Buffer, marker: int) -> int | str | bool | float:
-    if marker == LITERAL_INT:
+def read_literal(data: Buffer, tag: Tag) -> int | str | bool | float:
+    if tag == LITERAL_INT:
         return read_int(data)
-    elif marker == LITERAL_STR:
+    elif tag == LITERAL_STR:
         return read_str(data)
-    elif marker == LITERAL_BOOL:
+    elif tag == LITERAL_BOOL:
         return read_bool(data)
-    elif marker == LITERAL_FLOAT:
+    elif tag == LITERAL_FLOAT:
         return read_float(data)
-    assert False, f"Unknown literal marker {marker}"
+    assert False, f"Unknown literal tag {tag}"
 
 
 def write_literal(data: Buffer, value: int | str | bool | float | complex | None) -> None:
     if isinstance(value, bool):
-        write_int(data, LITERAL_BOOL)
+        write_tag(data, LITERAL_BOOL)
         write_bool(data, value)
     elif isinstance(value, int):
-        write_int(data, LITERAL_INT)
+        write_tag(data, LITERAL_INT)
         write_int(data, value)
     elif isinstance(value, str):
-        write_int(data, LITERAL_STR)
+        write_tag(data, LITERAL_STR)
         write_str(data, value)
     elif isinstance(value, float):
-        write_int(data, LITERAL_FLOAT)
+        write_tag(data, LITERAL_FLOAT)
         write_float(data, value)
     elif isinstance(value, complex):
-        write_int(data, LITERAL_COMPLEX)
+        write_tag(data, LITERAL_COMPLEX)
         write_float(data, value.real)
         write_float(data, value.imag)
     else:
-        write_int(data, LITERAL_NONE)
+        write_tag(data, LITERAL_NONE)
 
 
 def read_int_opt(data: Buffer) -> int | None:

mypy/checker.py

@@ -5552,10 +5552,10 @@ def visit_continue_stmt(self, s: ContinueStmt) -> None:
         return
 
     def visit_match_stmt(self, s: MatchStmt) -> None:
-        named_subject = self._make_named_statement_for_match(s)
         # In sync with similar actions elsewhere, narrow the target if
         # we are matching an AssignmentExpr
         unwrapped_subject = collapse_walrus(s.subject)
+        named_subject = self._make_named_statement_for_match(s, unwrapped_subject)
         with self.binder.frame_context(can_skip=False, fall_through=0):
             subject_type = get_proper_type(self.expr_checker.accept(s.subject))
 
@@ -5646,9 +5646,8 @@ def visit_match_stmt(self, s: MatchStmt) -> None:
             with self.binder.frame_context(can_skip=False, fall_through=2):
                 pass
 
-    def _make_named_statement_for_match(self, s: MatchStmt) -> Expression:
+    def _make_named_statement_for_match(self, s: MatchStmt, subject: Expression) -> Expression:
         """Construct a fake NameExpr for inference if a match clause is complex."""
-        subject = s.subject
         if self.binder.can_put_directly(subject):
             # Already named - we should infer type of it as given
             return subject

mypy/checker_shared.py

@@ -272,6 +272,10 @@ def checking_await_set(self) -> Iterator[None]:
     def get_precise_awaitable_type(self, typ: Type, local_errors: ErrorWatcher) -> Type | None:
         raise NotImplementedError
 
+    @abstractmethod
+    def add_any_attribute_to_type(self, typ: Type, name: str) -> Type:
+        raise NotImplementedError
+
     @abstractmethod
     def is_defined_in_stub(self, typ: Instance, /) -> bool:
         raise NotImplementedError

mypy/checkexpr.py

@@ -6004,6 +6004,10 @@ def analyze_cond_branch(
     def _combined_context(self, ty: Type | None) -> Type | None:
         ctx_items = []
         if ty is not None:
+            if has_any_type(ty):
+                # HACK: Any should be contagious, `dict[str, Any] or <x>` should still
+                # infer Any in x.
+                return ty
             ctx_items.append(ty)
         if self.type_context and self.type_context[-1] is not None:
             ctx_items.append(self.type_context[-1])

mypy/checkpattern.py

@@ -671,12 +671,15 @@ def visit_class_pattern(self, o: ClassPattern) -> PatternType:
                 has_local_errors = local_errors.has_new_errors()
             if has_local_errors or key_type is None:
                 key_type = AnyType(TypeOfAny.from_error)
-                self.msg.fail(
-                    message_registry.CLASS_PATTERN_UNKNOWN_KEYWORD.format(
-                        typ.str_with_options(self.options), keyword
-                    ),
-                    pattern,
-                )
+                if not (type_info and type_info.fullname == "builtins.object"):
+                    self.msg.fail(
+                        message_registry.CLASS_PATTERN_UNKNOWN_KEYWORD.format(
+                            typ.str_with_options(self.options), keyword
+                        ),
+                        pattern,
+                    )
+                elif keyword is not None:
+                    new_type = self.chk.add_any_attribute_to_type(new_type, keyword)
 
             inner_type, inner_rest_type, inner_captures = self.accept(pattern, key_type)
             if is_uninhabited(inner_type):

mypy/dmypy/client.py

@@ -36,9 +36,6 @@ def __init__(self, prog: str, **kwargs: Any) -> None:
 parser = argparse.ArgumentParser(
     prog="dmypy", description="Client for mypy daemon mode", fromfile_prefix_chars="@"
 )
-if sys.version_info >= (3, 14):
-    parser.color = True  # Set as init arg in 3.14
-
 parser.set_defaults(action=None)
 parser.add_argument(
     "--status-file", default=DEFAULT_STATUS_FILE, help="status file to retrieve daemon details"

mypy/fastparse.py

@@ -129,9 +129,7 @@
 PY_MINOR_VERSION: Final = sys.version_info[1]
 
 import ast as ast3
-
-# TODO: Index, ExtSlice are deprecated in 3.9.
-from ast import AST, Attribute, Call, FunctionType, Index, Name, Starred, UAdd, UnaryOp, USub
+from ast import AST, Attribute, Call, FunctionType, Name, Starred, UAdd, UnaryOp, USub
 
 
 def ast3_parse(
@@ -1779,18 +1777,6 @@ def visit_Slice(self, n: ast3.Slice) -> SliceExpr:
         e = SliceExpr(self.visit(n.lower), self.visit(n.upper), self.visit(n.step))
         return self.set_line(e, n)
 
-    # ExtSlice(slice* dims)
-    def visit_ExtSlice(self, n: ast3.ExtSlice) -> TupleExpr:
-        # cast for mypyc's benefit on Python 3.9
-        return TupleExpr(self.translate_expr_list(cast(Any, n).dims))
-
-    # Index(expr value)
-    def visit_Index(self, n: Index) -> Node:
-        # cast for mypyc's benefit on Python 3.9
-        value = self.visit(cast(Any, n).value)
-        assert isinstance(value, Node)
-        return value
-
     # Match(expr subject, match_case* cases) # python 3.10 and later
     def visit_Match(self, n: Match) -> MatchStmt:
         node = MatchStmt(

mypy/main.py

@@ -485,8 +485,6 @@ def define_options(
         stdout=stdout,
         stderr=stderr,
     )
-    if sys.version_info >= (3, 14):
-        parser.color = True  # Set as init arg in 3.14
 
     strict_flag_names: list[str] = []
     strict_flag_assignments: list[tuple[str, bool]] = []