From 3e034848a29acc374379ae68ff9c450fdb9cc2a2 Mon Sep 17 00:00:00 2001
From: Ilya Priven <ilya.konstantinov@gmail.com>
Date: Wed, 31 May 2023 03:07:25 -0400
Subject: [PATCH 001/129] Improve --update-data handler (#15283)

---
 mypy/test/data.py           |  42 ++++++++++-
 mypy/test/helpers.py        |  33 --------
 mypy/test/testcheck.py      |   5 +-
 mypy/test/testupdatedata.py | 146 ++++++++++++++++++++++++++++++++++++
 mypy/test/update.py         |   0
 mypy/test/update_data.py    |  85 +++++++++++++++++++++
 6 files changed, 274 insertions(+), 37 deletions(-)
 create mode 100644 mypy/test/testupdatedata.py
 delete mode 100644 mypy/test/update.py
 create mode 100644 mypy/test/update_data.py

diff --git a/mypy/test/data.py b/mypy/test/data.py
index 57d2377241d9a..daf815dbdbdcc 100644
--- a/mypy/test/data.py
+++ b/mypy/test/data.py
@@ -11,6 +11,7 @@
 import tempfile
 from abc import abstractmethod
 from dataclasses import dataclass
+from pathlib import Path
 from typing import Any, Iterator, NamedTuple, Pattern, Union
 from typing_extensions import Final, TypeAlias as _TypeAlias
 
@@ -426,8 +427,16 @@ class TestItem:
 
     id: str
     arg: str | None
+    # Processed, collapsed text data
     data: list[str]
+    # Start line: 1-based, inclusive, relative to testcase
     line: int
+    # End line: 1-based, exclusive, relative to testcase; not same as `line + len(test_item.data)` due to collapsing
+    end_line: int
+
+    @property
+    def trimmed_newlines(self) -> int:  # compensates for strip_list
+        return self.end_line - self.line - len(self.data)
 
 
 def parse_test_data(raw_data: str, name: str) -> list[TestItem]:
@@ -449,7 +458,7 @@ def parse_test_data(raw_data: str, name: str) -> list[TestItem]:
             if id:
                 data = collapse_line_continuation(data)
                 data = strip_list(data)
-                ret.append(TestItem(id, arg, strip_list(data), i0 + 1))
+                ret.append(TestItem(id, arg, data, i0 + 1, i))
 
             i0 = i
             id = s[1:-1]
@@ -470,7 +479,7 @@ def parse_test_data(raw_data: str, name: str) -> list[TestItem]:
     if id:
         data = collapse_line_continuation(data)
         data = strip_list(data)
-        ret.append(TestItem(id, arg, data, i0 + 1))
+        ret.append(TestItem(id, arg, data, i0 + 1, i - 1))
 
     return ret
 
@@ -693,6 +702,12 @@ def collect(self) -> Iterator[DataFileCollector]:
             yield DataFileCollector.from_parent(parent=self, name=data_file)
 
 
+class DataFileFix(NamedTuple):
+    lineno: int  # 1-offset, inclusive
+    end_lineno: int  # 1-offset, exclusive
+    lines: list[str]
+
+
 class DataFileCollector(pytest.Collector):
     """Represents a single `.test` data driven test file.
 
@@ -701,6 +716,8 @@ class DataFileCollector(pytest.Collector):
 
     parent: DataSuiteCollector
 
+    _fixes: list[DataFileFix]
+
     @classmethod  # We have to fight with pytest here:
     def from_parent(
         cls, parent: DataSuiteCollector, *, name: str  # type: ignore[override]
@@ -716,6 +733,27 @@ def collect(self) -> Iterator[DataDrivenTestCase]:
             file=os.path.join(self.parent.obj.data_prefix, self.name),
         )
 
+    def setup(self) -> None:
+        super().setup()
+        self._fixes = []
+
+    def teardown(self) -> None:
+        super().teardown()
+        self._apply_fixes()
+
+    def enqueue_fix(self, fix: DataFileFix) -> None:
+        self._fixes.append(fix)
+
+    def _apply_fixes(self) -> None:
+        if not self._fixes:
+            return
+        data_path = Path(self.parent.obj.data_prefix) / self.name
+        lines = data_path.read_text().split("\n")
+        # start from end to prevent line offsets from shifting as we update
+        for fix in sorted(self._fixes, reverse=True):
+            lines[fix.lineno - 1 : fix.end_lineno - 1] = fix.lines
+        data_path.write_text("\n".join(lines))
+
 
 def add_test_name_suffix(name: str, suffix: str) -> str:
     # Find magic suffix of form "-foobar" (used for things like "-skip").
diff --git a/mypy/test/helpers.py b/mypy/test/helpers.py
index ca9b02eac805a..849ccdc376bd5 100644
--- a/mypy/test/helpers.py
+++ b/mypy/test/helpers.py
@@ -141,39 +141,6 @@ def assert_target_equivalence(name: str, expected: list[str], actual: list[str])
     )
 
 
-def update_testcase_output(testcase: DataDrivenTestCase, output: list[str]) -> None:
-    assert testcase.old_cwd is not None, "test was not properly set up"
-    testcase_path = os.path.join(testcase.old_cwd, testcase.file)
-    with open(testcase_path, encoding="utf8") as f:
-        data_lines = f.read().splitlines()
-    test = "\n".join(data_lines[testcase.line : testcase.last_line])
-
-    mapping: dict[str, list[str]] = {}
-    for old, new in zip(testcase.output, output):
-        PREFIX = "error:"
-        ind = old.find(PREFIX)
-        if ind != -1 and old[:ind] == new[:ind]:
-            old, new = old[ind + len(PREFIX) :], new[ind + len(PREFIX) :]
-        mapping.setdefault(old, []).append(new)
-
-    for old in mapping:
-        if test.count(old) == len(mapping[old]):
-            betweens = test.split(old)
-
-            # Interleave betweens and mapping[old]
-            from itertools import chain
-
-            interleaved = [betweens[0]] + list(
-                chain.from_iterable(zip(mapping[old], betweens[1:]))
-            )
-            test = "".join(interleaved)
-
-    data_lines[testcase.line : testcase.last_line] = [test]
-    data = "\n".join(data_lines)
-    with open(testcase_path, "w", encoding="utf8") as f:
-        print(data, file=f)
-
-
 def show_align_message(s1: str, s2: str) -> None:
     """Align s1 and s2 so that the their first difference is highlighted.
 
diff --git a/mypy/test/testcheck.py b/mypy/test/testcheck.py
index fad70945f7400..58c0ee8033592 100644
--- a/mypy/test/testcheck.py
+++ b/mypy/test/testcheck.py
@@ -22,8 +22,8 @@
     normalize_error_messages,
     parse_options,
     perform_file_operations,
-    update_testcase_output,
 )
+from mypy.test.update_data import update_testcase_output
 
 try:
     import lxml  # type: ignore[import]
@@ -192,7 +192,8 @@ def run_case_once(
             output = testcase.output2.get(incremental_step, [])
 
         if output != a and testcase.config.getoption("--update-data", False):
-            update_testcase_output(testcase, a)
+            update_testcase_output(testcase, a, incremental_step=incremental_step)
+
         assert_string_arrays_equal(output, a, msg.format(testcase.file, testcase.line))
 
         if res:
diff --git a/mypy/test/testupdatedata.py b/mypy/test/testupdatedata.py
new file mode 100644
index 0000000000000..2e86c641ce6d3
--- /dev/null
+++ b/mypy/test/testupdatedata.py
@@ -0,0 +1,146 @@
+import shlex
+import subprocess
+import sys
+import textwrap
+from pathlib import Path
+
+from mypy.test.config import test_data_prefix
+from mypy.test.helpers import Suite
+
+
+class UpdateDataSuite(Suite):
+    def _run_pytest_update_data(self, data_suite: str, *, max_attempts: int) -> str:
+        """
+        Runs a suite of data test cases through 'pytest --update-data' until either tests pass
+        or until a maximum number of attempts (needed for incremental tests).
+        """
+        p = Path(test_data_prefix) / "check-update-data.test"
+        assert not p.exists()
+        try:
+            p.write_text(textwrap.dedent(data_suite).lstrip())
+
+            test_nodeid = f"mypy/test/testcheck.py::TypeCheckSuite::{p.name}"
+            args = [sys.executable, "-m", "pytest", "-n", "0", "-s", "--update-data", test_nodeid]
+            if sys.version_info >= (3, 8):
+                cmd = shlex.join(args)
+            else:
+                cmd = " ".join(args)
+            for i in range(max_attempts - 1, -1, -1):
+                res = subprocess.run(args)
+                if res.returncode == 0:
+                    break
+                print(f"`{cmd}` returned {res.returncode}: {i} attempts remaining")
+
+            return p.read_text()
+        finally:
+            p.unlink()
+
+    def test_update_data(self) -> None:
+        # Note: We test multiple testcases rather than 'test case per test case'
+        #       so we could also exercise rewriting multiple testcases at once.
+        actual = self._run_pytest_update_data(
+            """
+            [case testCorrect]
+            s: str = 42  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+
+            [case testWrong]
+            s: str = 42  # E: wrong error
+
+            [case testWrongMultiline]
+            s: str = 42  # E: foo \
+                         # N: bar
+
+            [case testMissingMultiline]
+            s: str = 42;  i: int = 'foo'
+
+            [case testExtraneous]
+            s: str = 'foo'  # E: wrong error
+
+            [case testExtraneousMultiline]
+            s: str = 'foo'  # E: foo \
+                            # E: bar
+
+            [case testExtraneousMultilineNonError]
+            s: str = 'foo'  # W: foo \
+                            # N: bar
+
+            [case testOutCorrect]
+            s: str = 42
+            [out]
+            main:1: error: Incompatible types in assignment (expression has type "int", variable has type "str")
+
+            [case testOutWrong]
+            s: str = 42
+            [out]
+            main:1: error: foobar
+
+            [case testOutWrongIncremental]
+            s: str = 42
+            [out]
+            main:1: error: foobar
+            [out2]
+            main:1: error: foobar
+
+            [case testWrongMultipleFiles]
+            import a, b
+            s: str = 42  # E: foo
+            [file a.py]
+            s1: str = 42  # E: bar
+            [file b.py]
+            s2: str = 43  # E: baz
+            [builtins fixtures/list.pyi]
+            """,
+            max_attempts=3,
+        )
+
+        # Assert
+        expected = """
+        [case testCorrect]
+        s: str = 42  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+
+        [case testWrong]
+        s: str = 42  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+
+        [case testWrongMultiline]
+        s: str = 42  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+
+        [case testMissingMultiline]
+        s: str = 42;  i: int = 'foo'  # E: Incompatible types in assignment (expression has type "int", variable has type "str") \\
+                                      # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+
+        [case testExtraneous]
+        s: str = 'foo'
+
+        [case testExtraneousMultiline]
+        s: str = 'foo'
+
+        [case testExtraneousMultilineNonError]
+        s: str = 'foo'
+
+        [case testOutCorrect]
+        s: str = 42
+        [out]
+        main:1: error: Incompatible types in assignment (expression has type "int", variable has type "str")
+
+        [case testOutWrong]
+        s: str = 42
+        [out]
+        main:1: error: Incompatible types in assignment (expression has type "int", variable has type "str")
+
+        [case testOutWrongIncremental]
+        s: str = 42
+        [out]
+        main:1: error: Incompatible types in assignment (expression has type "int", variable has type "str")
+        [out2]
+        main:1: error: Incompatible types in assignment (expression has type "int", variable has type "str")
+
+        [case testWrongMultipleFiles]
+        import a, b
+        s: str = 42  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+        [file a.py]
+        s1: str = 42  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+        [file b.py]
+        s2: str = 43  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+        [builtins fixtures/list.pyi]
+        """
+        assert actual == textwrap.dedent(expected).lstrip()
diff --git a/mypy/test/update.py b/mypy/test/update.py
deleted file mode 100644
index e69de29bb2d1d..0000000000000
diff --git a/mypy/test/update_data.py b/mypy/test/update_data.py
new file mode 100644
index 0000000000000..b37b440de38f6
--- /dev/null
+++ b/mypy/test/update_data.py
@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import re
+from collections import defaultdict
+from typing import Iterator
+
+from mypy.test.data import DataDrivenTestCase, DataFileCollector, DataFileFix, parse_test_data
+
+
+def update_testcase_output(
+    testcase: DataDrivenTestCase, actual: list[str], *, incremental_step: int
+) -> None:
+    collector = testcase.parent
+    assert isinstance(collector, DataFileCollector)
+    for fix in _iter_fixes(testcase, actual, incremental_step=incremental_step):
+        collector.enqueue_fix(fix)
+
+
+def _iter_fixes(
+    testcase: DataDrivenTestCase, actual: list[str], *, incremental_step: int
+) -> Iterator[DataFileFix]:
+    reports_by_line: dict[tuple[str, int], list[tuple[str, str]]] = defaultdict(list)
+    for error_line in actual:
+        comment_match = re.match(
+            r"^(?P<filename>[^:]+):(?P<lineno>\d+): (?P<severity>error|note|warning): (?P<msg>.+)$",
+            error_line,
+        )
+        if comment_match:
+            filename = comment_match.group("filename")
+            lineno = int(comment_match.group("lineno"))
+            severity = comment_match.group("severity")
+            msg = comment_match.group("msg")
+            reports_by_line[filename, lineno].append((severity, msg))
+
+    test_items = parse_test_data(testcase.data, testcase.name)
+
+    # If we have [out] and/or [outN], we update just those sections.
+    if any(re.match(r"^out\d*$", test_item.id) for test_item in test_items):
+        for test_item in test_items:
+            if (incremental_step < 2 and test_item.id == "out") or (
+                incremental_step >= 2 and test_item.id == f"out{incremental_step}"
+            ):
+                yield DataFileFix(
+                    lineno=testcase.line + test_item.line - 1,
+                    end_lineno=testcase.line + test_item.end_line - 1,
+                    lines=actual + [""] * test_item.trimmed_newlines,
+                )
+
+        return
+
+    # Update assertion comments within the sections
+    for test_item in test_items:
+        if test_item.id == "case":
+            source_lines = test_item.data
+            file_path = "main"
+        elif test_item.id == "file":
+            source_lines = test_item.data
+            file_path = f"tmp/{test_item.arg}"
+        else:
+            continue  # other sections we don't touch
+
+        fix_lines = []
+        for lineno, source_line in enumerate(source_lines, start=1):
+            reports = reports_by_line.get((file_path, lineno))
+            comment_match = re.search(r"(?P<indent>\s+)(?P<comment># [EWN]: .+)$", source_line)
+            if comment_match:
+                source_line = source_line[: comment_match.start("indent")]  # strip old comment
+            if reports:
+                indent = comment_match.group("indent") if comment_match else "  "
+                # multiline comments are on the first line and then on subsequent lines emtpy lines
+                # with a continuation backslash
+                for j, (severity, msg) in enumerate(reports):
+                    out_l = source_line if j == 0 else " " * len(source_line)
+                    is_last = j == len(reports) - 1
+                    severity_char = severity[0].upper()
+                    continuation = "" if is_last else " \\"
+                    fix_lines.append(f"{out_l}{indent}# {severity_char}: {msg}{continuation}")
+            else:
+                fix_lines.append(source_line)
+
+        yield DataFileFix(
+            lineno=testcase.line + test_item.line - 1,
+            end_lineno=testcase.line + test_item.end_line - 1,
+            lines=fix_lines + [""] * test_item.trimmed_newlines,
+        )

From 3d2f43772262060fdb1921933da6dc8c7d8ad8a1 Mon Sep 17 00:00:00 2001
From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
Date: Wed, 31 May 2023 12:20:23 +0200
Subject: [PATCH 002/129] Fix crash with custom ErrorCodes (#15327)

A class marked with `allow_interpreted_subclasses=True` implicitly
supports serialization while also allowing it to be subclassed by pure
Python code.

Fixes #15255


https://mypyc.readthedocs.io/en/latest/differences_from_python.html#pickling-and-copying-objects
https://mypyc.readthedocs.io/en/latest/native_classes.html#inheritance
---
 mypy/errorcodes.py                         |  2 +-
 test-data/unit/check-custom-plugin.test    | 12 ++++++++++++
 test-data/unit/plugins/custom_errorcode.py | 20 ++++++++++++++++++++
 3 files changed, 33 insertions(+), 1 deletion(-)
 create mode 100644 test-data/unit/plugins/custom_errorcode.py

diff --git a/mypy/errorcodes.py b/mypy/errorcodes.py
index fe460fdec7447..50a82be9816d5 100644
--- a/mypy/errorcodes.py
+++ b/mypy/errorcodes.py
@@ -14,7 +14,7 @@
 sub_code_map: dict[str, set[str]] = defaultdict(set)
 
 
-@mypyc_attr(serializable=True)
+@mypyc_attr(allow_interpreted_subclasses=True)
 class ErrorCode:
     def __init__(
         self,
diff --git a/test-data/unit/check-custom-plugin.test b/test-data/unit/check-custom-plugin.test
index d7beea0390e7f..c81de675d8082 100644
--- a/test-data/unit/check-custom-plugin.test
+++ b/test-data/unit/check-custom-plugin.test
@@ -1014,3 +1014,15 @@ reveal_type(MyClass.foo_staticmethod)  # N: Revealed type is "def (builtins.int)
 [file mypy.ini]
 \[mypy]
 plugins=<ROOT>/test-data/unit/plugins/add_classmethod.py
+
+[case testCustomErrorCodePlugin]
+# flags: --config-file tmp/mypy.ini  --show-error-codes
+def main() -> int:
+    return 2
+
+main()  # E: Custom error  [custom]
+reveal_type(1)  # N: Revealed type is "Literal[1]?"
+
+[file mypy.ini]
+\[mypy]
+plugins=<ROOT>/test-data/unit/plugins/custom_errorcode.py
diff --git a/test-data/unit/plugins/custom_errorcode.py b/test-data/unit/plugins/custom_errorcode.py
new file mode 100644
index 0000000000000..0e2209a32ecab
--- /dev/null
+++ b/test-data/unit/plugins/custom_errorcode.py
@@ -0,0 +1,20 @@
+from mypy.errorcodes import ErrorCode
+from mypy.plugin import Plugin
+from mypy.types import AnyType, TypeOfAny
+
+CUSTOM_ERROR = ErrorCode(code="custom", description="", category="Custom")
+
+
+class CustomErrorCodePlugin(Plugin):
+    def get_function_hook(self, fullname):
+        if fullname.endswith(".main"):
+            return self.emit_error
+        return None
+
+    def emit_error(self, ctx):
+        ctx.api.fail("Custom error", ctx.context, code=CUSTOM_ERROR)
+        return AnyType(TypeOfAny.from_error)
+
+
+def plugin(version):
+    return CustomErrorCodePlugin

From d11db284368e73e0e277fb9134ef5f3a0b0618e6 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Wed, 31 May 2023 19:05:30 -0700
Subject: [PATCH 003/129] Sync typeshed (#15334)

Co-authored-by: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
Co-authored-by: hauntsaninja <hauntsaninja@gmail.com>
---
 mypy/typeshed/stdlib/VERSIONS                |   6 +-
 mypy/typeshed/stdlib/_collections_abc.pyi    |  11 ++
 mypy/typeshed/stdlib/_ctypes.pyi             |   2 +
 mypy/typeshed/stdlib/_typeshed/__init__.pyi  |  71 +++++------
 mypy/typeshed/stdlib/argparse.pyi            |  22 ++--
 mypy/typeshed/stdlib/array.pyi               |   2 +
 mypy/typeshed/stdlib/asyncio/__init__.pyi    |   4 +-
 mypy/typeshed/stdlib/asyncio/base_events.pyi |  10 +-
 mypy/typeshed/stdlib/asyncio/events.pyi      |  11 +-
 mypy/typeshed/stdlib/asyncio/tasks.pyi       |  19 ++-
 mypy/typeshed/stdlib/binhex.pyi              |   6 +-
 mypy/typeshed/stdlib/builtins.pyi            |  12 +-
 mypy/typeshed/stdlib/fcntl.pyi               |  12 +-
 mypy/typeshed/stdlib/fractions.pyi           |   8 +-
 mypy/typeshed/stdlib/gzip.pyi                |   6 +-
 mypy/typeshed/stdlib/hmac.pyi                |   4 +-
 mypy/typeshed/stdlib/imaplib.pyi             |   4 +-
 mypy/typeshed/stdlib/inspect.pyi             |  22 ++++
 mypy/typeshed/stdlib/json/__init__.pyi       |   9 ++
 mypy/typeshed/stdlib/logging/handlers.pyi    |   2 +-
 mypy/typeshed/stdlib/math.pyi                |   9 +-
 mypy/typeshed/stdlib/mmap.pyi                |   2 +
 mypy/typeshed/stdlib/pickle.pyi              |   2 +
 mypy/typeshed/stdlib/random.pyi              |  13 +-
 mypy/typeshed/stdlib/shutil.pyi              |  46 +++++--
 mypy/typeshed/stdlib/smtplib.pyi             |   4 +-
 mypy/typeshed/stdlib/statistics.pyi          |   9 +-
 mypy/typeshed/stdlib/typing.pyi              | 125 +++++++++++++++----
 mypy/typeshed/stdlib/typing_extensions.pyi   | 123 ++++++++++++++----
 mypy/typeshed/stdlib/weakref.pyi             |   2 +-
 mypy/typeshed/stdlib/xmlrpc/client.pyi       |  10 +-
 mypy/typeshed/stdlib/zipfile.pyi             |   4 +-
 test-data/unit/pythoneval.test               |   4 +-
 33 files changed, 425 insertions(+), 171 deletions(-)

diff --git a/mypy/typeshed/stdlib/VERSIONS b/mypy/typeshed/stdlib/VERSIONS
index d24aa35faf6ea..86e8da78677c8 100644
--- a/mypy/typeshed/stdlib/VERSIONS
+++ b/mypy/typeshed/stdlib/VERSIONS
@@ -61,7 +61,7 @@ antigravity: 2.7-
 argparse: 2.7-
 array: 2.7-
 ast: 2.7-
-asynchat: 2.7-
+asynchat: 2.7-3.11
 asyncio: 3.4-
 asyncio.mixins: 3.10-
 asyncio.exceptions: 3.8-
@@ -72,7 +72,7 @@ asyncio.taskgroups: 3.11-
 asyncio.threads: 3.9-
 asyncio.timeouts: 3.11-
 asyncio.trsock: 3.8-
-asyncore: 2.7-
+asyncore: 2.7-3.11
 atexit: 2.7-
 audioop: 2.7-
 base64: 2.7-
@@ -228,7 +228,7 @@ shlex: 2.7-
 shutil: 2.7-
 signal: 2.7-
 site: 2.7-
-smtpd: 2.7-
+smtpd: 2.7-3.11
 smtplib: 2.7-
 sndhdr: 2.7-
 socket: 2.7-
diff --git a/mypy/typeshed/stdlib/_collections_abc.pyi b/mypy/typeshed/stdlib/_collections_abc.pyi
index 352da6cfb3319..05b5421c21f33 100644
--- a/mypy/typeshed/stdlib/_collections_abc.pyi
+++ b/mypy/typeshed/stdlib/_collections_abc.pyi
@@ -1,4 +1,5 @@
 import sys
+from abc import abstractmethod
 from types import MappingProxyType
 from typing import (  # noqa: Y022,Y038
     AbstractSet as Set,
@@ -23,11 +24,13 @@ from typing import (  # noqa: Y022,Y038
     MutableMapping as MutableMapping,
     MutableSequence as MutableSequence,
     MutableSet as MutableSet,
+    Protocol,
     Reversible as Reversible,
     Sequence as Sequence,
     Sized as Sized,
     TypeVar,
     ValuesView as ValuesView,
+    runtime_checkable,
 )
 from typing_extensions import final
 
@@ -58,6 +61,8 @@ __all__ = [
     "MutableSequence",
     "ByteString",
 ]
+if sys.version_info >= (3, 12):
+    __all__ += ["Buffer"]
 
 _KT_co = TypeVar("_KT_co", covariant=True)  # Key type covariant containers.
 _VT_co = TypeVar("_VT_co", covariant=True)  # Value type covariant containers.
@@ -79,3 +84,9 @@ class dict_items(ItemsView[_KT_co, _VT_co], Generic[_KT_co, _VT_co]):  # undocum
     if sys.version_info >= (3, 10):
         @property
         def mapping(self) -> MappingProxyType[_KT_co, _VT_co]: ...
+
+if sys.version_info >= (3, 12):
+    @runtime_checkable
+    class Buffer(Protocol):
+        @abstractmethod
+        def __buffer__(self, __flags: int) -> memoryview: ...
diff --git a/mypy/typeshed/stdlib/_ctypes.pyi b/mypy/typeshed/stdlib/_ctypes.pyi
index 4f8de4605d4da..8e8bcbe84bd4d 100644
--- a/mypy/typeshed/stdlib/_ctypes.pyi
+++ b/mypy/typeshed/stdlib/_ctypes.pyi
@@ -63,6 +63,8 @@ class _CData(metaclass=_CDataMeta):
     def from_param(cls, obj: Any) -> Self | _CArgObject: ...
     @classmethod
     def in_dll(cls, library: CDLL, name: str) -> Self: ...
+    def __buffer__(self, __flags: int) -> memoryview: ...
+    def __release_buffer__(self, __buffer: memoryview) -> None: ...
 
 class _SimpleCData(Generic[_T], _CData):
     value: _T
diff --git a/mypy/typeshed/stdlib/_typeshed/__init__.pyi b/mypy/typeshed/stdlib/_typeshed/__init__.pyi
index 3c29032b6b0dd..5d03142c6d71f 100644
--- a/mypy/typeshed/stdlib/_typeshed/__init__.pyi
+++ b/mypy/typeshed/stdlib/_typeshed/__init__.pyi
@@ -2,17 +2,13 @@
 #
 # See the README.md file in this directory for more information.
 
-import array
-import ctypes
-import mmap
-import pickle
 import sys
-from collections.abc import Awaitable, Callable, Iterable, Set as AbstractSet
+from collections.abc import Awaitable, Callable, Iterable, Sequence, Set as AbstractSet, Sized
 from dataclasses import Field
 from os import PathLike
 from types import FrameType, TracebackType
-from typing import Any, AnyStr, ClassVar, Generic, Protocol, TypeVar
-from typing_extensions import Final, Literal, LiteralString, TypeAlias, final
+from typing import Any, AnyStr, ClassVar, Generic, Protocol, TypeVar, overload
+from typing_extensions import Buffer, Final, Literal, LiteralString, TypeAlias, final
 
 _KT = TypeVar("_KT")
 _KT_co = TypeVar("_KT_co", covariant=True)
@@ -227,42 +223,33 @@ class SupportsNoArgReadline(Protocol[_T_co]):
 class SupportsWrite(Protocol[_T_contra]):
     def write(self, __s: _T_contra) -> object: ...
 
-ReadOnlyBuffer: TypeAlias = bytes  # stable
+# Unfortunately PEP 688 does not allow us to distinguish read-only
+# from writable buffers. We use these aliases for readability for now.
+# Perhaps a future extension of the buffer protocol will allow us to
+# distinguish these cases in the type system.
+ReadOnlyBuffer: TypeAlias = Buffer  # stable
 # Anything that implements the read-write buffer interface.
-# The buffer interface is defined purely on the C level, so we cannot define a normal Protocol
-# for it (until PEP 688 is implemented). Instead we have to list the most common stdlib buffer classes in a Union.
-if sys.version_info >= (3, 8):
-    WriteableBuffer: TypeAlias = (
-        bytearray | memoryview | array.array[Any] | mmap.mmap | ctypes._CData | pickle.PickleBuffer
-    )  # stable
-else:
-    WriteableBuffer: TypeAlias = bytearray | memoryview | array.array[Any] | mmap.mmap | ctypes._CData  # stable
-# Same as _WriteableBuffer, but also includes read-only buffer types (like bytes).
-ReadableBuffer: TypeAlias = ReadOnlyBuffer | WriteableBuffer  # stable
-_BufferWithLen: TypeAlias = ReadableBuffer  # not stable  # noqa: Y047
-
-# Anything that implements the read-write buffer interface, and can be sliced/indexed.
-SliceableBuffer: TypeAlias = bytes | bytearray | memoryview | array.array[Any] | mmap.mmap
-IndexableBuffer: TypeAlias = bytes | bytearray | memoryview | array.array[Any] | mmap.mmap
-# https://github.com/python/typeshed/pull/9115#issuecomment-1304905864
-# Post PEP 688, they should be rewritten as such:
-# from collections.abc import Sequence
-# from typing import Sized, overload
-# class SliceableBuffer(Protocol):
-#     def __buffer__(self, __flags: int) -> memoryview: ...
-#     def __getitem__(self, __slice: slice) -> Sequence[int]: ...
-# class IndexableBuffer(Protocol):
-#     def __buffer__(self, __flags: int) -> memoryview: ...
-#     def __getitem__(self, __i: int) -> int: ...
-# class SupportsGetItemBuffer(SliceableBuffer, IndexableBuffer, Protocol):
-#     def __buffer__(self, __flags: int) -> memoryview: ...
-#     def __contains__(self, __x: Any) -> bool: ...
-#     @overload
-#     def __getitem__(self, __slice: slice) -> Sequence[int]: ...
-#     @overload
-#     def __getitem__(self, __i: int) -> int: ...
-# class SizedBuffer(Sized, Protocol):  # instead of _BufferWithLen
-#     def __buffer__(self, __flags: int) -> memoryview: ...
+WriteableBuffer: TypeAlias = Buffer
+# Same as WriteableBuffer, but also includes read-only buffer types (like bytes).
+ReadableBuffer: TypeAlias = Buffer  # stable
+
+class SliceableBuffer(Buffer, Protocol):
+    def __getitem__(self, __slice: slice) -> Sequence[int]: ...
+
+class IndexableBuffer(Buffer, Protocol):
+    def __getitem__(self, __i: int) -> int: ...
+
+class SupportsGetItemBuffer(SliceableBuffer, IndexableBuffer, Protocol):
+    def __contains__(self, __x: Any) -> bool: ...
+    @overload
+    def __getitem__(self, __slice: slice) -> Sequence[int]: ...
+    @overload
+    def __getitem__(self, __i: int) -> int: ...
+
+class SizedBuffer(Sized, Buffer, Protocol): ...
+
+# for compatibility with third-party stubs that may use this
+_BufferWithLen: TypeAlias = SizedBuffer  # not stable  # noqa: Y047
 
 ExcInfo: TypeAlias = tuple[type[BaseException], BaseException, TracebackType]
 OptExcInfo: TypeAlias = ExcInfo | tuple[None, None, None]
diff --git a/mypy/typeshed/stdlib/argparse.pyi b/mypy/typeshed/stdlib/argparse.pyi
index 1e956069314bf..c986b9cdb0820 100644
--- a/mypy/typeshed/stdlib/argparse.pyi
+++ b/mypy/typeshed/stdlib/argparse.pyi
@@ -2,7 +2,7 @@ import sys
 from collections.abc import Callable, Generator, Iterable, Sequence
 from re import Pattern
 from typing import IO, Any, Generic, NewType, NoReturn, Protocol, TypeVar, overload
-from typing_extensions import Literal, TypeAlias
+from typing_extensions import Literal, Self, TypeAlias
 
 __all__ = [
     "ArgumentParser",
@@ -236,11 +236,19 @@ class HelpFormatter:
     _current_indent: int
     _level: int
     _action_max_length: int
-    _root_section: Any
-    _current_section: Any
+    _root_section: _Section
+    _current_section: _Section
     _whitespace_matcher: Pattern[str]
     _long_break_matcher: Pattern[str]
-    _Section: type[Any]  # Nested class
+
+    class _Section:
+        formatter: HelpFormatter
+        heading: str | None
+        parent: Self | None
+        items: list[tuple[Callable[..., str], Iterable[Any]]]
+        def __init__(self, formatter: HelpFormatter, parent: Self | None, heading: str | None = None) -> None: ...
+        def format_help(self) -> str: ...
+
     def __init__(self, prog: str, indent_increment: int = 2, max_help_position: int = 24, width: int | None = None) -> None: ...
     def _indent(self) -> None: ...
     def _dedent(self) -> None: ...
@@ -249,16 +257,16 @@ class HelpFormatter:
     def end_section(self) -> None: ...
     def add_text(self, text: str | None) -> None: ...
     def add_usage(
-        self, usage: str | None, actions: Iterable[Action], groups: Iterable[_ArgumentGroup], prefix: str | None = None
+        self, usage: str | None, actions: Iterable[Action], groups: Iterable[_MutuallyExclusiveGroup], prefix: str | None = None
     ) -> None: ...
     def add_argument(self, action: Action) -> None: ...
     def add_arguments(self, actions: Iterable[Action]) -> None: ...
     def format_help(self) -> str: ...
     def _join_parts(self, part_strings: Iterable[str]) -> str: ...
     def _format_usage(
-        self, usage: str | None, actions: Iterable[Action], groups: Iterable[_ArgumentGroup], prefix: str | None
+        self, usage: str | None, actions: Iterable[Action], groups: Iterable[_MutuallyExclusiveGroup], prefix: str | None
     ) -> str: ...
-    def _format_actions_usage(self, actions: Iterable[Action], groups: Iterable[_ArgumentGroup]) -> str: ...
+    def _format_actions_usage(self, actions: Iterable[Action], groups: Iterable[_MutuallyExclusiveGroup]) -> str: ...
     def _format_text(self, text: str) -> str: ...
     def _format_action(self, action: Action) -> str: ...
     def _format_action_invocation(self, action: Action) -> str: ...
diff --git a/mypy/typeshed/stdlib/array.pyi b/mypy/typeshed/stdlib/array.pyi
index 38a815b584cd3..8b003503bc9ba 100644
--- a/mypy/typeshed/stdlib/array.pyi
+++ b/mypy/typeshed/stdlib/array.pyi
@@ -80,5 +80,7 @@ class array(MutableSequence[_T], Generic[_T]):
     def __rmul__(self, __value: int) -> array[_T]: ...
     def __copy__(self) -> array[_T]: ...
     def __deepcopy__(self, __unused: Any) -> array[_T]: ...
+    def __buffer__(self, __flags: int) -> memoryview: ...
+    def __release_buffer__(self, __buffer: memoryview) -> None: ...
 
 ArrayType = array
diff --git a/mypy/typeshed/stdlib/asyncio/__init__.pyi b/mypy/typeshed/stdlib/asyncio/__init__.pyi
index c4e000d2323a0..2ce066cac9821 100644
--- a/mypy/typeshed/stdlib/asyncio/__init__.pyi
+++ b/mypy/typeshed/stdlib/asyncio/__init__.pyi
@@ -1,5 +1,5 @@
 import sys
-from collections.abc import Coroutine, Generator
+from collections.abc import Awaitable, Coroutine, Generator
 from typing import Any, TypeVar
 from typing_extensions import TypeAlias
 
@@ -36,6 +36,8 @@ _T = TypeVar("_T")
 
 # Aliases imported by multiple submodules in typeshed
 if sys.version_info >= (3, 12):
+    _AwaitableLike: TypeAlias = Awaitable[_T]
     _CoroutineLike: TypeAlias = Coroutine[Any, Any, _T]
 else:
+    _AwaitableLike: TypeAlias = Generator[Any, None, _T] | Awaitable[_T]
     _CoroutineLike: TypeAlias = Generator[Any, None, _T] | Coroutine[Any, Any, _T]
diff --git a/mypy/typeshed/stdlib/asyncio/base_events.pyi b/mypy/typeshed/stdlib/asyncio/base_events.pyi
index 9dcefc8b33085..fd765fdb06143 100644
--- a/mypy/typeshed/stdlib/asyncio/base_events.pyi
+++ b/mypy/typeshed/stdlib/asyncio/base_events.pyi
@@ -1,13 +1,13 @@
 import ssl
 import sys
 from _typeshed import FileDescriptorLike, ReadableBuffer, WriteableBuffer
-from asyncio import _CoroutineLike
+from asyncio import _AwaitableLike, _CoroutineLike
 from asyncio.events import AbstractEventLoop, AbstractServer, Handle, TimerHandle, _TaskFactory
 from asyncio.futures import Future
 from asyncio.protocols import BaseProtocol
 from asyncio.tasks import Task
 from asyncio.transports import BaseTransport, DatagramTransport, ReadTransport, SubprocessTransport, Transport, WriteTransport
-from collections.abc import Awaitable, Callable, Generator, Iterable, Sequence
+from collections.abc import Callable, Iterable, Sequence
 from contextvars import Context
 from socket import AddressFamily, SocketKind, _Address, _RetAddress, socket
 from typing import IO, Any, TypeVar, overload
@@ -64,11 +64,7 @@ class Server(AbstractServer):
 
 class BaseEventLoop(AbstractEventLoop):
     def run_forever(self) -> None: ...
-    # Can't use a union, see mypy issue  # 1873.
-    @overload
-    def run_until_complete(self, future: Generator[Any, None, _T]) -> _T: ...
-    @overload
-    def run_until_complete(self, future: Awaitable[_T]) -> _T: ...
+    def run_until_complete(self, future: _AwaitableLike[_T]) -> _T: ...
     def stop(self) -> None: ...
     def is_running(self) -> bool: ...
     def is_closed(self) -> bool: ...
diff --git a/mypy/typeshed/stdlib/asyncio/events.pyi b/mypy/typeshed/stdlib/asyncio/events.pyi
index 4776aaa5df0ca..11112bb2e87d5 100644
--- a/mypy/typeshed/stdlib/asyncio/events.pyi
+++ b/mypy/typeshed/stdlib/asyncio/events.pyi
@@ -2,13 +2,13 @@ import ssl
 import sys
 from _typeshed import FileDescriptorLike, ReadableBuffer, StrPath, Unused, WriteableBuffer
 from abc import ABCMeta, abstractmethod
-from collections.abc import Awaitable, Callable, Coroutine, Generator, Sequence
+from collections.abc import Callable, Coroutine, Generator, Sequence
 from contextvars import Context
 from socket import AddressFamily, SocketKind, _Address, _RetAddress, socket
 from typing import IO, Any, Protocol, TypeVar, overload
 from typing_extensions import Literal, Self, TypeAlias
 
-from . import _CoroutineLike
+from . import _AwaitableLike, _CoroutineLike
 from .base_events import Server
 from .futures import Future
 from .protocols import BaseProtocol
@@ -113,13 +113,8 @@ class AbstractEventLoop:
     slow_callback_duration: float
     @abstractmethod
     def run_forever(self) -> None: ...
-    # Can't use a union, see mypy issue  # 1873.
-    @overload
     @abstractmethod
-    def run_until_complete(self, future: Generator[Any, None, _T]) -> _T: ...
-    @overload
-    @abstractmethod
-    def run_until_complete(self, future: Awaitable[_T]) -> _T: ...
+    def run_until_complete(self, future: _AwaitableLike[_T]) -> _T: ...
     @abstractmethod
     def stop(self) -> None: ...
     @abstractmethod
diff --git a/mypy/typeshed/stdlib/asyncio/tasks.pyi b/mypy/typeshed/stdlib/asyncio/tasks.pyi
index 478f190554658..d8c101f281fc0 100644
--- a/mypy/typeshed/stdlib/asyncio/tasks.pyi
+++ b/mypy/typeshed/stdlib/asyncio/tasks.pyi
@@ -1,6 +1,6 @@
 import concurrent.futures
 import sys
-from collections.abc import Awaitable, Generator, Iterable, Iterator
+from collections.abc import Awaitable, Coroutine, Generator, Iterable, Iterator
 from types import FrameType
 from typing import Any, Generic, TextIO, TypeVar, overload
 from typing_extensions import Literal, TypeAlias
@@ -275,6 +275,11 @@ else:
     ) -> tuple[set[Task[_T]], set[Task[_T]]]: ...
     async def wait_for(fut: _FutureLike[_T], timeout: float | None, *, loop: AbstractEventLoop | None = None) -> _T: ...
 
+if sys.version_info >= (3, 12):
+    _TaskCompatibleCoro: TypeAlias = Coroutine[Any, Any, _T_co]
+else:
+    _TaskCompatibleCoro: TypeAlias = Generator[_TaskYieldType, None, _T_co] | Awaitable[_T_co]
+
 # mypy and pyright complain that a subclass of an invariant class shouldn't be covariant.
 # While this is true in general, here it's sort-of okay to have a covariant subclass,
 # since the only reason why `asyncio.Future` is invariant is the `set_result()` method,
@@ -282,18 +287,12 @@ else:
 class Task(Future[_T_co], Generic[_T_co]):  # type: ignore[type-var]  # pyright: ignore[reportGeneralTypeIssues]
     if sys.version_info >= (3, 8):
         def __init__(
-            self,
-            coro: Generator[_TaskYieldType, None, _T_co] | Awaitable[_T_co],
-            *,
-            loop: AbstractEventLoop = ...,
-            name: str | None = ...,
+            self, coro: _TaskCompatibleCoro[_T_co], *, loop: AbstractEventLoop = ..., name: str | None = ...
         ) -> None: ...
     else:
-        def __init__(
-            self, coro: Generator[_TaskYieldType, None, _T_co] | Awaitable[_T_co], *, loop: AbstractEventLoop = ...
-        ) -> None: ...
+        def __init__(self, coro: _TaskCompatibleCoro[_T_co], *, loop: AbstractEventLoop = ...) -> None: ...
     if sys.version_info >= (3, 8):
-        def get_coro(self) -> Generator[_TaskYieldType, None, _T_co] | Awaitable[_T_co]: ...
+        def get_coro(self) -> _TaskCompatibleCoro[_T_co]: ...
         def get_name(self) -> str: ...
         def set_name(self, __value: object) -> None: ...
 
diff --git a/mypy/typeshed/stdlib/binhex.pyi b/mypy/typeshed/stdlib/binhex.pyi
index e0993c840ce74..64ba9f6150b43 100644
--- a/mypy/typeshed/stdlib/binhex.pyi
+++ b/mypy/typeshed/stdlib/binhex.pyi
@@ -1,4 +1,4 @@
-from _typeshed import _BufferWithLen
+from _typeshed import SizedBuffer
 from typing import IO, Any
 from typing_extensions import Literal, TypeAlias
 
@@ -28,9 +28,9 @@ class openrsrc:
 
 class BinHex:
     def __init__(self, name_finfo_dlen_rlen: _FileInfoTuple, ofp: _FileHandleUnion) -> None: ...
-    def write(self, data: _BufferWithLen) -> None: ...
+    def write(self, data: SizedBuffer) -> None: ...
     def close_data(self) -> None: ...
-    def write_rsrc(self, data: _BufferWithLen) -> None: ...
+    def write_rsrc(self, data: SizedBuffer) -> None: ...
     def close(self) -> None: ...
 
 def binhex(inp: str, out: str) -> None: ...
diff --git a/mypy/typeshed/stdlib/builtins.pyi b/mypy/typeshed/stdlib/builtins.pyi
index c72da4aba3353..0676aba1277ed 100644
--- a/mypy/typeshed/stdlib/builtins.pyi
+++ b/mypy/typeshed/stdlib/builtins.pyi
@@ -36,7 +36,6 @@ from typing import (  # noqa: Y022
     IO,
     Any,
     BinaryIO,
-    ByteString,
     ClassVar,
     Generic,
     Mapping,
@@ -500,7 +499,7 @@ class str(Sequence[str]):
     def __rmul__(self, __value: SupportsIndex) -> str: ...  # type: ignore[misc]
     def __getnewargs__(self) -> tuple[str]: ...
 
-class bytes(ByteString):
+class bytes(Sequence[int]):
     @overload
     def __new__(cls, __o: Iterable[SupportsIndex] | SupportsIndex | SupportsBytes | ReadableBuffer) -> Self: ...
     @overload
@@ -603,7 +602,9 @@ class bytes(ByteString):
     if sys.version_info >= (3, 11):
         def __bytes__(self) -> bytes: ...
 
-class bytearray(MutableSequence[int], ByteString):
+    def __buffer__(self, __flags: int) -> memoryview: ...
+
+class bytearray(MutableSequence[int]):
     @overload
     def __init__(self) -> None: ...
     @overload
@@ -718,6 +719,8 @@ class bytearray(MutableSequence[int], ByteString):
     def __gt__(self, __value: ReadableBuffer) -> bool: ...
     def __ge__(self, __value: ReadableBuffer) -> bool: ...
     def __alloc__(self) -> int: ...
+    def __buffer__(self, __flags: int) -> memoryview: ...
+    def __release_buffer__(self, __buffer: memoryview) -> None: ...
 
 @final
 class memoryview(Sequence[int]):
@@ -779,6 +782,9 @@ class memoryview(Sequence[int]):
     else:
         def hex(self) -> str: ...
 
+    def __buffer__(self, __flags: int) -> memoryview: ...
+    def __release_buffer__(self, __buffer: memoryview) -> None: ...
+
 @final
 class bool(int):
     def __new__(cls, __o: object = ...) -> Self: ...
diff --git a/mypy/typeshed/stdlib/fcntl.pyi b/mypy/typeshed/stdlib/fcntl.pyi
index 90676e3657123..01443083f48de 100644
--- a/mypy/typeshed/stdlib/fcntl.pyi
+++ b/mypy/typeshed/stdlib/fcntl.pyi
@@ -1,7 +1,7 @@
 import sys
 from _typeshed import FileDescriptorLike, ReadOnlyBuffer, WriteableBuffer
 from typing import Any, overload
-from typing_extensions import Literal
+from typing_extensions import Buffer, Literal
 
 if sys.platform != "win32":
     FASYNC: int
@@ -104,13 +104,19 @@ if sys.platform != "win32":
     def fcntl(__fd: FileDescriptorLike, __cmd: int, __arg: int = 0) -> int: ...
     @overload
     def fcntl(__fd: FileDescriptorLike, __cmd: int, __arg: str | ReadOnlyBuffer) -> bytes: ...
+    # If arg is an int, return int
     @overload
     def ioctl(__fd: FileDescriptorLike, __request: int, __arg: int = 0, __mutate_flag: bool = True) -> int: ...
+    # The return type works as follows:
+    # - If arg is a read-write buffer, return int if mutate_flag is True, otherwise bytes
+    # - If arg is a read-only buffer, return bytes (and ignore the value of mutate_flag)
+    # We can't represent that precisely as we can't distinguish between read-write and read-only
+    # buffers, so we add overloads for a few unambiguous cases and use Any for the rest.
     @overload
-    def ioctl(__fd: FileDescriptorLike, __request: int, __arg: WriteableBuffer, __mutate_flag: Literal[True] = True) -> int: ...
+    def ioctl(__fd: FileDescriptorLike, __request: int, __arg: bytes, __mutate_flag: bool = True) -> bytes: ...
     @overload
     def ioctl(__fd: FileDescriptorLike, __request: int, __arg: WriteableBuffer, __mutate_flag: Literal[False]) -> bytes: ...
     @overload
-    def ioctl(__fd: FileDescriptorLike, __request: int, __arg: ReadOnlyBuffer, __mutate_flag: bool = True) -> bytes: ...
+    def ioctl(__fd: FileDescriptorLike, __request: int, __arg: Buffer, __mutate_flag: bool = True) -> Any: ...
     def flock(__fd: FileDescriptorLike, __operation: int) -> None: ...
     def lockf(__fd: FileDescriptorLike, __cmd: int, __len: int = 0, __start: int = 0, __whence: int = 0) -> Any: ...
diff --git a/mypy/typeshed/stdlib/fractions.pyi b/mypy/typeshed/stdlib/fractions.pyi
index 3c84978c1bad7..7ec8addeb1367 100644
--- a/mypy/typeshed/stdlib/fractions.pyi
+++ b/mypy/typeshed/stdlib/fractions.pyi
@@ -22,11 +22,9 @@ else:
 
 class Fraction(Rational):
     @overload
-    def __new__(
-        cls, numerator: int | Rational = 0, denominator: int | Rational | None = None, *, _normalize: bool = True
-    ) -> Self: ...
+    def __new__(cls, numerator: int | Rational = 0, denominator: int | Rational | None = None) -> Self: ...
     @overload
-    def __new__(cls, __value: float | Decimal | str, *, _normalize: bool = True) -> Self: ...
+    def __new__(cls, __value: float | Decimal | str) -> Self: ...
     @classmethod
     def from_float(cls, f: float) -> Self: ...
     @classmethod
@@ -34,6 +32,8 @@ class Fraction(Rational):
     def limit_denominator(self, max_denominator: int = 1000000) -> Fraction: ...
     if sys.version_info >= (3, 8):
         def as_integer_ratio(self) -> tuple[int, int]: ...
+    if sys.version_info >= (3, 12):
+        def is_integer(self) -> bool: ...
 
     @property
     def numerator(a) -> int: ...
diff --git a/mypy/typeshed/stdlib/gzip.pyi b/mypy/typeshed/stdlib/gzip.pyi
index 6a794f381ad6f..1ec8b4b8ca7c2 100644
--- a/mypy/typeshed/stdlib/gzip.pyi
+++ b/mypy/typeshed/stdlib/gzip.pyi
@@ -1,7 +1,7 @@
 import _compression
 import sys
 import zlib
-from _typeshed import ReadableBuffer, StrOrBytesPath, _BufferWithLen
+from _typeshed import ReadableBuffer, SizedBuffer, StrOrBytesPath
 from io import FileIO
 from typing import Protocol, TextIO, overload
 from typing_extensions import Literal, TypeAlias
@@ -159,9 +159,9 @@ class _GzipReader(_compression.DecompressReader):
     def __init__(self, fp: _ReadableFileobj) -> None: ...
 
 if sys.version_info >= (3, 8):
-    def compress(data: _BufferWithLen, compresslevel: int = 9, *, mtime: float | None = None) -> bytes: ...
+    def compress(data: SizedBuffer, compresslevel: int = 9, *, mtime: float | None = None) -> bytes: ...
 
 else:
-    def compress(data: _BufferWithLen, compresslevel: int = 9) -> bytes: ...
+    def compress(data: SizedBuffer, compresslevel: int = 9) -> bytes: ...
 
 def decompress(data: ReadableBuffer) -> bytes: ...
diff --git a/mypy/typeshed/stdlib/hmac.pyi b/mypy/typeshed/stdlib/hmac.pyi
index ee8af1b48d83b..9ff99a5a05d57 100644
--- a/mypy/typeshed/stdlib/hmac.pyi
+++ b/mypy/typeshed/stdlib/hmac.pyi
@@ -1,5 +1,5 @@
 import sys
-from _typeshed import ReadableBuffer, _BufferWithLen
+from _typeshed import ReadableBuffer, SizedBuffer
 from collections.abc import Callable
 from types import ModuleType
 from typing import Any, AnyStr, overload
@@ -46,4 +46,4 @@ class HMAC:
 def compare_digest(__a: ReadableBuffer, __b: ReadableBuffer) -> bool: ...
 @overload
 def compare_digest(__a: AnyStr, __b: AnyStr) -> bool: ...
-def digest(key: _BufferWithLen, msg: ReadableBuffer, digest: _DigestMod) -> bytes: ...
+def digest(key: SizedBuffer, msg: ReadableBuffer, digest: _DigestMod) -> bytes: ...
diff --git a/mypy/typeshed/stdlib/imaplib.pyi b/mypy/typeshed/stdlib/imaplib.pyi
index 1c2112dd37c8f..7781559c38885 100644
--- a/mypy/typeshed/stdlib/imaplib.pyi
+++ b/mypy/typeshed/stdlib/imaplib.pyi
@@ -1,7 +1,7 @@
 import subprocess
 import sys
 import time
-from _typeshed import ReadableBuffer, _BufferWithLen
+from _typeshed import ReadableBuffer, SizedBuffer
 from builtins import list as _list  # conflicts with a method named "list"
 from collections.abc import Callable
 from datetime import datetime
@@ -155,7 +155,7 @@ class _Authenticator:
     def __init__(self, mechinst: Callable[[bytes], bytes | bytearray | memoryview | str | None]) -> None: ...
     def process(self, data: str) -> str: ...
     def encode(self, inp: bytes | bytearray | memoryview) -> str: ...
-    def decode(self, inp: str | _BufferWithLen) -> bytes: ...
+    def decode(self, inp: str | SizedBuffer) -> bytes: ...
 
 def Internaldate2tuple(resp: ReadableBuffer) -> time.struct_time | None: ...
 def Int2AP(num: SupportsAbs[SupportsInt]) -> bytes: ...
diff --git a/mypy/typeshed/stdlib/inspect.pyi b/mypy/typeshed/stdlib/inspect.pyi
index a2252e38ee8ca..2d004a8e6b573 100644
--- a/mypy/typeshed/stdlib/inspect.pyi
+++ b/mypy/typeshed/stdlib/inspect.pyi
@@ -598,3 +598,25 @@ def classify_class_attrs(cls: type) -> list[Attribute]: ...
 
 if sys.version_info >= (3, 9):
     class ClassFoundException(Exception): ...
+
+if sys.version_info >= (3, 12):
+    class BufferFlags(enum.IntFlag):
+        SIMPLE: int
+        WRITABLE: int
+        FORMAT: int
+        ND: int
+        STRIDES: int
+        C_CONTIGUOUS: int
+        F_CONTIGUOUS: int
+        ANY_CONTIGUOUS: int
+        INDIRECT: int
+        CONTIG: int
+        CONTIG_RO: int
+        STRIDED: int
+        STRIDED_RO: int
+        RECORDS: int
+        RECORDS_RO: int
+        FULL: int
+        FULL_RO: int
+        READ: int
+        WRITE: int
diff --git a/mypy/typeshed/stdlib/json/__init__.pyi b/mypy/typeshed/stdlib/json/__init__.pyi
index 63e9718ee1512..dc0cdff926d4f 100644
--- a/mypy/typeshed/stdlib/json/__init__.pyi
+++ b/mypy/typeshed/stdlib/json/__init__.pyi
@@ -1,3 +1,4 @@
+import sys
 from _typeshed import SupportsRead, SupportsWrite
 from collections.abc import Callable
 from typing import Any
@@ -6,6 +7,8 @@ from .decoder import JSONDecodeError as JSONDecodeError, JSONDecoder as JSONDeco
 from .encoder import JSONEncoder as JSONEncoder
 
 __all__ = ["dump", "dumps", "load", "loads", "JSONDecoder", "JSONDecodeError", "JSONEncoder"]
+if sys.version_info >= (3, 12):
+    __all__ += ["AttrDict"]
 
 def dumps(
     obj: Any,
@@ -59,3 +62,9 @@ def load(
     **kwds: Any,
 ) -> Any: ...
 def detect_encoding(b: bytes | bytearray) -> str: ...  # undocumented
+
+if sys.version_info >= (3, 12):
+    class AttrDict(dict[str, Any]):
+        def __getattr__(self, name: str) -> Any: ...
+        def __setattr__(self, name: str, value: Any) -> None: ...
+        def __delattr__(self, name: str) -> None: ...
diff --git a/mypy/typeshed/stdlib/logging/handlers.pyi b/mypy/typeshed/stdlib/logging/handlers.pyi
index 3a7c8ade74981..ad5bf392b50fc 100644
--- a/mypy/typeshed/stdlib/logging/handlers.pyi
+++ b/mypy/typeshed/stdlib/logging/handlers.pyi
@@ -179,7 +179,7 @@ class SysLogHandler(Handler):
     facility_names: ClassVar[dict[str, int]]  # undocumented
     priority_map: ClassVar[dict[str, str]]  # undocumented
     def __init__(
-        self, address: tuple[str, int] | str = ("localhost", 514), facility: int = 1, socktype: SocketKind | None = None
+        self, address: tuple[str, int] | str = ("localhost", 514), facility: str | int = 1, socktype: SocketKind | None = None
     ) -> None: ...
     if sys.version_info >= (3, 11):
         def createSocket(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/math.pyi b/mypy/typeshed/stdlib/math.pyi
index 231964f397db4..4a4d592b860d1 100644
--- a/mypy/typeshed/stdlib/math.pyi
+++ b/mypy/typeshed/stdlib/math.pyi
@@ -112,7 +112,10 @@ def log1p(__x: _SupportsFloatOrIndex) -> float: ...
 def log2(__x: _SupportsFloatOrIndex) -> float: ...
 def modf(__x: _SupportsFloatOrIndex) -> tuple[float, float]: ...
 
-if sys.version_info >= (3, 9):
+if sys.version_info >= (3, 12):
+    def nextafter(__x: _SupportsFloatOrIndex, __y: _SupportsFloatOrIndex, *, steps: SupportsIndex | None = None) -> float: ...
+
+elif sys.version_info >= (3, 9):
     def nextafter(__x: _SupportsFloatOrIndex, __y: _SupportsFloatOrIndex) -> float: ...
 
 if sys.version_info >= (3, 8):
@@ -130,6 +133,10 @@ def radians(__x: _SupportsFloatOrIndex) -> float: ...
 def remainder(__x: _SupportsFloatOrIndex, __y: _SupportsFloatOrIndex) -> float: ...
 def sin(__x: _SupportsFloatOrIndex) -> float: ...
 def sinh(__x: _SupportsFloatOrIndex) -> float: ...
+
+if sys.version_info >= (3, 12):
+    def sumprod(__p: Iterable[float], __q: Iterable[float]) -> float: ...
+
 def sqrt(__x: _SupportsFloatOrIndex) -> float: ...
 def tan(__x: _SupportsFloatOrIndex) -> float: ...
 def tanh(__x: _SupportsFloatOrIndex) -> float: ...
diff --git a/mypy/typeshed/stdlib/mmap.pyi b/mypy/typeshed/stdlib/mmap.pyi
index 8da4ea7ca8647..38e1924392c49 100644
--- a/mypy/typeshed/stdlib/mmap.pyi
+++ b/mypy/typeshed/stdlib/mmap.pyi
@@ -76,6 +76,8 @@ class mmap(Iterable[int], Sized):
     def __iter__(self) -> Iterator[int]: ...
     def __enter__(self) -> Self: ...
     def __exit__(self, *args: Unused) -> None: ...
+    def __buffer__(self, __flags: int) -> memoryview: ...
+    def __release_buffer__(self, __buffer: memoryview) -> None: ...
 
 if sys.version_info >= (3, 8) and sys.platform != "win32":
     MADV_NORMAL: int
diff --git a/mypy/typeshed/stdlib/pickle.pyi b/mypy/typeshed/stdlib/pickle.pyi
index 55ff38585b958..cf3995d74f5d0 100644
--- a/mypy/typeshed/stdlib/pickle.pyi
+++ b/mypy/typeshed/stdlib/pickle.pyi
@@ -103,6 +103,8 @@ if sys.version_info >= (3, 8):
         def __init__(self, buffer: ReadableBuffer) -> None: ...
         def raw(self) -> memoryview: ...
         def release(self) -> None: ...
+        def __buffer__(self, __flags: int) -> memoryview: ...
+        def __release_buffer__(self, __buffer: memoryview) -> None: ...
     _BufferCallback: TypeAlias = Callable[[PickleBuffer], Any] | None
     def dump(
         obj: Any,
diff --git a/mypy/typeshed/stdlib/random.pyi b/mypy/typeshed/stdlib/random.pyi
index 5434f22407cc4..9fd1c64f2bba2 100644
--- a/mypy/typeshed/stdlib/random.pyi
+++ b/mypy/typeshed/stdlib/random.pyi
@@ -34,6 +34,8 @@ __all__ = [
 
 if sys.version_info >= (3, 9):
     __all__ += ["randbytes"]
+if sys.version_info >= (3, 12):
+    __all__ += ["binomialvariate"]
 
 _T = TypeVar("_T")
 
@@ -79,8 +81,15 @@ class Random(_random.Random):
 
     def uniform(self, a: float, b: float) -> float: ...
     def triangular(self, low: float = 0.0, high: float = 1.0, mode: float | None = None) -> float: ...
+    if sys.version_info >= (3, 12):
+        def binomialvariate(self, n: int = 1, p: float = 0.5) -> int: ...
+
     def betavariate(self, alpha: float, beta: float) -> float: ...
-    def expovariate(self, lambd: float) -> float: ...
+    if sys.version_info >= (3, 12):
+        def expovariate(self, lambd: float = 1.0) -> float: ...
+    else:
+        def expovariate(self, lambd: float) -> float: ...
+
     def gammavariate(self, alpha: float, beta: float) -> float: ...
     if sys.version_info >= (3, 11):
         def gauss(self, mu: float = 0.0, sigma: float = 1.0) -> float: ...
@@ -117,6 +126,8 @@ expovariate = _inst.expovariate
 vonmisesvariate = _inst.vonmisesvariate
 gammavariate = _inst.gammavariate
 gauss = _inst.gauss
+if sys.version_info >= (3, 12):
+    binomialvariate = _inst.binomialvariate
 betavariate = _inst.betavariate
 paretovariate = _inst.paretovariate
 weibullvariate = _inst.weibullvariate
diff --git a/mypy/typeshed/stdlib/shutil.pyi b/mypy/typeshed/stdlib/shutil.pyi
index e8eb468337e13..ef716d4049dd9 100644
--- a/mypy/typeshed/stdlib/shutil.pyi
+++ b/mypy/typeshed/stdlib/shutil.pyi
@@ -87,22 +87,46 @@ else:
         ignore_dangling_symlinks: bool = False,
     ) -> _PathReturn: ...
 
-_OnErrorCallback: TypeAlias = Callable[[Callable[..., Any], Any, Any], object]
+_OnErrorCallback: TypeAlias = Callable[[Callable[..., Any], str, Any], object]
+_OnExcCallback: TypeAlias = Callable[[Callable[..., Any], str, Exception], object]
 
 class _RmtreeType(Protocol):
     avoids_symlink_attacks: bool
-    if sys.version_info >= (3, 11):
+    if sys.version_info >= (3, 12):
+        @overload
         def __call__(
             self,
             path: StrOrBytesPath,
-            ignore_errors: bool = ...,
-            onerror: _OnErrorCallback | None = ...,
+            ignore_errors: bool = False,
+            onerror: _OnErrorCallback | None = None,
             *,
-            dir_fd: int | None = ...,
+            onexc: None = None,
+            dir_fd: int | None = None,
+        ) -> None: ...
+        @overload
+        def __call__(
+            self,
+            path: StrOrBytesPath,
+            ignore_errors: bool = False,
+            onerror: None = None,
+            *,
+            onexc: _OnExcCallback,
+            dir_fd: int | None = None,
+        ) -> None: ...
+    elif sys.version_info >= (3, 11):
+        def __call__(
+            self,
+            path: StrOrBytesPath,
+            ignore_errors: bool = False,
+            onerror: _OnErrorCallback | None = None,
+            *,
+            dir_fd: int | None = None,
         ) -> None: ...
 
     else:
-        def __call__(self, path: StrOrBytesPath, ignore_errors: bool = ..., onerror: _OnErrorCallback | None = ...) -> None: ...
+        def __call__(
+            self, path: StrOrBytesPath, ignore_errors: bool = False, onerror: _OnErrorCallback | None = None
+        ) -> None: ...
 
 rmtree: _RmtreeType
 
@@ -167,7 +191,15 @@ def register_archive_format(
     name: str, function: Callable[[str, str], object], extra_args: None = None, description: str = ""
 ) -> None: ...
 def unregister_archive_format(name: str) -> None: ...
-def unpack_archive(filename: StrPath, extract_dir: StrPath | None = None, format: str | None = None) -> None: ...
+
+if sys.version_info >= (3, 12):
+    def unpack_archive(
+        filename: StrPath, extract_dir: StrPath | None = None, format: str | None = None, *, filter: str | None = None
+    ) -> None: ...
+
+else:
+    def unpack_archive(filename: StrPath, extract_dir: StrPath | None = None, format: str | None = None) -> None: ...
+
 @overload
 def register_unpack_format(
     name: str,
diff --git a/mypy/typeshed/stdlib/smtplib.pyi b/mypy/typeshed/stdlib/smtplib.pyi
index 4228ad551eba6..584fa164fec94 100644
--- a/mypy/typeshed/stdlib/smtplib.pyi
+++ b/mypy/typeshed/stdlib/smtplib.pyi
@@ -1,6 +1,6 @@
 import sys
 from _socket import _Address as _SourceAddress
-from _typeshed import ReadableBuffer, _BufferWithLen
+from _typeshed import ReadableBuffer, SizedBuffer
 from collections.abc import Sequence
 from email.message import Message as _Message
 from re import Pattern
@@ -133,7 +133,7 @@ class SMTP:
         self,
         from_addr: str,
         to_addrs: str | Sequence[str],
-        msg: _BufferWithLen | str,
+        msg: SizedBuffer | str,
         mail_options: Sequence[str] = (),
         rcpt_options: Sequence[str] = (),
     ) -> _SendErrs: ...
diff --git a/mypy/typeshed/stdlib/statistics.pyi b/mypy/typeshed/stdlib/statistics.pyi
index 1358b1f90d7d1..af5fcec6ad0cb 100644
--- a/mypy/typeshed/stdlib/statistics.pyi
+++ b/mypy/typeshed/stdlib/statistics.pyi
@@ -114,8 +114,15 @@ if sys.version_info >= (3, 8):
         def __rsub__(self, x2: float | NormalDist) -> NormalDist: ...
         __rmul__ = __mul__
 
-if sys.version_info >= (3, 10):
+if sys.version_info >= (3, 12):
+    def correlation(
+        __x: Sequence[_Number], __y: Sequence[_Number], *, method: Literal["linear", "ranked"] = "linear"
+    ) -> float: ...
+
+elif sys.version_info >= (3, 10):
     def correlation(__x: Sequence[_Number], __y: Sequence[_Number]) -> float: ...
+
+if sys.version_info >= (3, 10):
     def covariance(__x: Sequence[_Number], __y: Sequence[_Number]) -> float: ...
 
     class LinearRegression(NamedTuple):
diff --git a/mypy/typeshed/stdlib/typing.pyi b/mypy/typeshed/stdlib/typing.pyi
index 6fc677dcbdc94..db042dc440ae8 100644
--- a/mypy/typeshed/stdlib/typing.pyi
+++ b/mypy/typeshed/stdlib/typing.pyi
@@ -136,14 +136,32 @@ Any = object()
 
 @_final
 class TypeVar:
-    __name__: str
-    __bound__: Any | None
-    __constraints__: tuple[Any, ...]
-    __covariant__: bool
-    __contravariant__: bool
-    def __init__(
-        self, name: str, *constraints: Any, bound: Any | None = None, covariant: bool = False, contravariant: bool = False
-    ) -> None: ...
+    @property
+    def __name__(self) -> str: ...
+    @property
+    def __bound__(self) -> Any | None: ...
+    @property
+    def __constraints__(self) -> tuple[Any, ...]: ...
+    @property
+    def __covariant__(self) -> bool: ...
+    @property
+    def __contravariant__(self) -> bool: ...
+    if sys.version_info >= (3, 12):
+        @property
+        def __infer_variance__(self) -> bool: ...
+        def __init__(
+            self,
+            name: str,
+            *constraints: Any,
+            bound: Any | None = None,
+            covariant: bool = False,
+            contravariant: bool = False,
+            infer_variance: bool = False,
+        ) -> None: ...
+    else:
+        def __init__(
+            self, name: str, *constraints: Any, bound: Any | None = None, covariant: bool = False, contravariant: bool = False
+        ) -> None: ...
     if sys.version_info >= (3, 10):
         def __or__(self, right: Any) -> _SpecialForm: ...
         def __ror__(self, left: Any) -> _SpecialForm: ...
@@ -193,30 +211,55 @@ if sys.version_info >= (3, 11):
     NotRequired: _SpecialForm
     LiteralString: _SpecialForm
 
+    @_final
     class TypeVarTuple:
-        __name__: str
+        @property
+        def __name__(self) -> str: ...
         def __init__(self, name: str) -> None: ...
         def __iter__(self) -> Any: ...
         def __typing_subst__(self, arg: Never) -> Never: ...
         def __typing_prepare_subst__(self, alias: Incomplete, args: Incomplete) -> Incomplete: ...
 
 if sys.version_info >= (3, 10):
+    @_final
     class ParamSpecArgs:
-        __origin__: ParamSpec
+        @property
+        def __origin__(self) -> ParamSpec: ...
         def __init__(self, origin: ParamSpec) -> None: ...
 
+    @_final
     class ParamSpecKwargs:
-        __origin__: ParamSpec
+        @property
+        def __origin__(self) -> ParamSpec: ...
         def __init__(self, origin: ParamSpec) -> None: ...
 
+    @_final
     class ParamSpec:
-        __name__: str
-        __bound__: Any | None
-        __covariant__: bool
-        __contravariant__: bool
-        def __init__(
-            self, name: str, *, bound: Any | None = None, contravariant: bool = False, covariant: bool = False
-        ) -> None: ...
+        @property
+        def __name__(self) -> str: ...
+        @property
+        def __bound__(self) -> Any | None: ...
+        @property
+        def __covariant__(self) -> bool: ...
+        @property
+        def __contravariant__(self) -> bool: ...
+        if sys.version_info >= (3, 12):
+            @property
+            def __infer_variance__(self) -> bool: ...
+            def __init__(
+                self,
+                name: str,
+                *,
+                bound: Any | None = None,
+                contravariant: bool = False,
+                covariant: bool = False,
+                infer_variance: bool = False,
+            ) -> None: ...
+        else:
+            def __init__(
+                self, name: str, *, bound: Any | None = None, contravariant: bool = False, covariant: bool = False
+            ) -> None: ...
+
         @property
         def args(self) -> ParamSpecArgs: ...
         @property
@@ -233,7 +276,7 @@ if sys.version_info >= (3, 10):
 
     class NewType:
         def __init__(self, name: str, tp: Any) -> None: ...
-        def __call__(self, x: _T) -> _T: ...
+        def __call__(self, __x: _T) -> _T: ...
         def __or__(self, other: Any) -> _SpecialForm: ...
         def __ror__(self, other: Any) -> _SpecialForm: ...
         __supertype__: type
@@ -728,7 +771,7 @@ class TextIO(IO[str]):
     @abstractmethod
     def __enter__(self) -> TextIO: ...
 
-class ByteString(Sequence[int], metaclass=ABCMeta): ...
+ByteString: typing_extensions.TypeAlias = bytes | bytearray | memoryview
 
 # Functions
 
@@ -800,18 +843,21 @@ if sys.version_info >= (3, 11):
 
 class NamedTuple(tuple[Any, ...]):
     if sys.version_info < (3, 8):
-        _field_types: collections.OrderedDict[str, type]
+        _field_types: ClassVar[collections.OrderedDict[str, type]]
     elif sys.version_info < (3, 9):
-        _field_types: dict[str, type]
-    _field_defaults: dict[str, Any]
-    _fields: tuple[str, ...]
-    _source: str
+        _field_types: ClassVar[dict[str, type]]
+    _field_defaults: ClassVar[dict[str, Any]]
+    _fields: ClassVar[tuple[str, ...]]
+    # __orig_bases__ sometimes exists on <3.12, but not consistently
+    # So we only add it to the stub on 3.12+.
+    if sys.version_info >= (3, 12):
+        __orig_bases__: ClassVar[tuple[Any, ...]]
     @overload
     def __init__(self, typename: str, fields: Iterable[tuple[str, Any]] = ...) -> None: ...
     @overload
     def __init__(self, typename: str, fields: None = None, **kwargs: Any) -> None: ...
     @classmethod
-    def _make(cls: Type[_T], iterable: Iterable[Any]) -> _T: ...
+    def _make(cls, iterable: Iterable[Any]) -> typing_extensions.Self: ...
     if sys.version_info >= (3, 8):
         def _asdict(self) -> dict[str, Any]: ...
     else:
@@ -827,6 +873,10 @@ class _TypedDict(Mapping[str, object], metaclass=ABCMeta):
     if sys.version_info >= (3, 9):
         __required_keys__: ClassVar[frozenset[str]]
         __optional_keys__: ClassVar[frozenset[str]]
+    # __orig_bases__ sometimes exists on <3.12, but not consistently,
+    # so we only add it to the stub on 3.12+
+    if sys.version_info >= (3, 12):
+        __orig_bases__: ClassVar[tuple[Any, ...]]
     def copy(self) -> typing_extensions.Self: ...
     # Using Never so that only calls using mypy plugin hook that specialize the signature
     # can go through.
@@ -873,3 +923,26 @@ if sys.version_info >= (3, 10):
     def is_typeddict(tp: object) -> bool: ...
 
 def _type_repr(obj: object) -> str: ...
+
+if sys.version_info >= (3, 12):
+    def override(__arg: _F) -> _F: ...
+    @_final
+    class TypeAliasType:
+        def __init__(
+            self, name: str, value: Any, *, type_params: tuple[TypeVar | ParamSpec | TypeVarTuple, ...] = ()
+        ) -> None: ...
+        @property
+        def __value__(self) -> Any: ...
+        @property
+        def __type_params__(self) -> tuple[TypeVar | ParamSpec | TypeVarTuple, ...]: ...
+        @property
+        def __parameters__(self) -> tuple[Any, ...]: ...
+        @property
+        def __name__(self) -> str: ...
+        # It's writable on types, but not on instances of TypeAliasType.
+        @property
+        def __module__(self) -> str | None: ...  # type: ignore[override]
+        def __getitem__(self, parameters: Any) -> Any: ...
+        if sys.version_info >= (3, 10):
+            def __or__(self, right: Any) -> _SpecialForm: ...
+            def __ror__(self, left: Any) -> _SpecialForm: ...
diff --git a/mypy/typeshed/stdlib/typing_extensions.pyi b/mypy/typeshed/stdlib/typing_extensions.pyi
index d567d8b96fafa..93087a45a108d 100644
--- a/mypy/typeshed/stdlib/typing_extensions.pyi
+++ b/mypy/typeshed/stdlib/typing_extensions.pyi
@@ -22,9 +22,14 @@ from typing import (  # noqa: Y022,Y039
     DefaultDict as DefaultDict,
     Deque as Deque,
     Mapping,
-    NewType as NewType,
     NoReturn as NoReturn,
     Sequence,
+    SupportsAbs as SupportsAbs,
+    SupportsBytes as SupportsBytes,
+    SupportsComplex as SupportsComplex,
+    SupportsFloat as SupportsFloat,
+    SupportsInt as SupportsInt,
+    SupportsRound as SupportsRound,
     Text as Text,
     Type as Type,
     _Alias,
@@ -39,6 +44,7 @@ if sys.version_info >= (3, 9):
 
 __all__ = [
     "Any",
+    "Buffer",
     "ClassVar",
     "Concatenate",
     "Final",
@@ -66,6 +72,12 @@ __all__ = [
     "OrderedDict",
     "TypedDict",
     "SupportsIndex",
+    "SupportsAbs",
+    "SupportsRound",
+    "SupportsBytes",
+    "SupportsComplex",
+    "SupportsFloat",
+    "SupportsInt",
     "Annotated",
     "assert_never",
     "assert_type",
@@ -84,6 +96,7 @@ __all__ = [
     "runtime_checkable",
     "Text",
     "TypeAlias",
+    "TypeAliasType",
     "TypeGuard",
     "TYPE_CHECKING",
     "Never",
@@ -93,6 +106,7 @@ __all__ = [
     "clear_overloads",
     "get_args",
     "get_origin",
+    "get_original_bases",
     "get_overloads",
     "get_type_hints",
 ]
@@ -134,6 +148,7 @@ class _TypedDict(Mapping[str, object], metaclass=abc.ABCMeta):
     __required_keys__: ClassVar[frozenset[str]]
     __optional_keys__: ClassVar[frozenset[str]]
     __total__: ClassVar[bool]
+    __orig_bases__: ClassVar[tuple[Any, ...]]
     def copy(self) -> Self: ...
     # Using Never so that only calls using mypy plugin hook that specialize the signature
     # can go through.
@@ -183,10 +198,11 @@ class SupportsIndex(Protocol, metaclass=abc.ABCMeta):
     @abc.abstractmethod
     def __index__(self) -> int: ...
 
-# New things in 3.10
+# New and changed things in 3.10
 if sys.version_info >= (3, 10):
     from typing import (
         Concatenate as Concatenate,
+        NewType as NewType,
         ParamSpecArgs as ParamSpecArgs,
         ParamSpecKwargs as ParamSpecKwargs,
         TypeAlias as TypeAlias,
@@ -194,12 +210,16 @@ if sys.version_info >= (3, 10):
         is_typeddict as is_typeddict,
     )
 else:
+    @final
     class ParamSpecArgs:
-        __origin__: ParamSpec
+        @property
+        def __origin__(self) -> ParamSpec: ...
         def __init__(self, origin: ParamSpec) -> None: ...
 
+    @final
     class ParamSpecKwargs:
-        __origin__: ParamSpec
+        @property
+        def __origin__(self) -> ParamSpec: ...
         def __init__(self, origin: ParamSpec) -> None: ...
 
     Concatenate: _SpecialForm
@@ -207,6 +227,11 @@ else:
     TypeGuard: _SpecialForm
     def is_typeddict(tp: object) -> bool: ...
 
+    class NewType:
+        def __init__(self, name: str, tp: Any) -> None: ...
+        def __call__(self, __x: _T) -> _T: ...
+        __supertype__: type
+
 # New things in 3.11
 # NamedTuples are not new, but the ability to create generic NamedTuples is new in 3.11
 if sys.version_info >= (3, 11):
@@ -251,12 +276,12 @@ else:
 
     class NamedTuple(tuple[Any, ...]):
         if sys.version_info < (3, 8):
-            _field_types: collections.OrderedDict[str, type]
+            _field_types: ClassVar[collections.OrderedDict[str, type]]
         elif sys.version_info < (3, 9):
-            _field_types: dict[str, type]
-        _field_defaults: dict[str, Any]
-        _fields: tuple[str, ...]
-        _source: str
+            _field_types: ClassVar[dict[str, type]]
+        _field_defaults: ClassVar[dict[str, Any]]
+        _fields: ClassVar[tuple[str, ...]]
+        __orig_bases__: ClassVar[tuple[Any, ...]]
         @overload
         def __init__(self, typename: str, fields: Iterable[tuple[str, Any]] = ...) -> None: ...
         @overload
@@ -272,16 +297,24 @@ else:
 
 # New things in 3.xx
 # The `default` parameter was added to TypeVar, ParamSpec, and TypeVarTuple (PEP 696)
-# The `infer_variance` parameter was added to TypeVar (PEP 695)
+# The `infer_variance` parameter was added to TypeVar in 3.12 (PEP 695)
 # typing_extensions.override (PEP 698)
 @final
 class TypeVar:
-    __name__: str
-    __bound__: Any | None
-    __constraints__: tuple[Any, ...]
-    __covariant__: bool
-    __contravariant__: bool
-    __default__: Any | None
+    @property
+    def __name__(self) -> str: ...
+    @property
+    def __bound__(self) -> Any | None: ...
+    @property
+    def __constraints__(self) -> tuple[Any, ...]: ...
+    @property
+    def __covariant__(self) -> bool: ...
+    @property
+    def __contravariant__(self) -> bool: ...
+    @property
+    def __infer_variance__(self) -> bool: ...
+    @property
+    def __default__(self) -> Any | None: ...
     def __init__(
         self,
         name: str,
@@ -300,11 +333,18 @@ class TypeVar:
 
 @final
 class ParamSpec:
-    __name__: str
-    __bound__: type[Any] | None
-    __covariant__: bool
-    __contravariant__: bool
-    __default__: type[Any] | None
+    @property
+    def __name__(self) -> str: ...
+    @property
+    def __bound__(self) -> Any | None: ...
+    @property
+    def __covariant__(self) -> bool: ...
+    @property
+    def __contravariant__(self) -> bool: ...
+    @property
+    def __infer_variance__(self) -> bool: ...
+    @property
+    def __default__(self) -> Any | None: ...
     def __init__(
         self,
         name: str,
@@ -321,10 +361,45 @@ class ParamSpec:
 
 @final
 class TypeVarTuple:
-    __name__: str
-    __default__: Any | None
+    @property
+    def __name__(self) -> str: ...
+    @property
+    def __default__(self) -> Any | None: ...
     def __init__(self, name: str, *, default: Any | None = None) -> None: ...
     def __iter__(self) -> Any: ...  # Unpack[Self]
 
-def override(__arg: _F) -> _F: ...
 def deprecated(__msg: str, *, category: type[Warning] | None = ..., stacklevel: int = 1) -> Callable[[_T], _T]: ...
+
+if sys.version_info >= (3, 12):
+    from collections.abc import Buffer as Buffer
+    from types import get_original_bases as get_original_bases
+    from typing import TypeAliasType as TypeAliasType, override as override
+else:
+    def override(__arg: _F) -> _F: ...
+    def get_original_bases(__cls: type) -> tuple[Any, ...]: ...
+    @final
+    class TypeAliasType:
+        def __init__(
+            self, name: str, value: Any, *, type_params: tuple[TypeVar | ParamSpec | TypeVarTuple, ...] = ()
+        ) -> None: ...
+        @property
+        def __value__(self) -> Any: ...
+        @property
+        def __type_params__(self) -> tuple[TypeVar | ParamSpec | TypeVarTuple, ...]: ...
+        @property
+        def __parameters__(self) -> tuple[Any, ...]: ...
+        @property
+        def __name__(self) -> str: ...
+        # It's writable on types, but not on instances of TypeAliasType.
+        @property
+        def __module__(self) -> str | None: ...  # type: ignore[override]
+        def __getitem__(self, parameters: Any) -> Any: ...
+        if sys.version_info >= (3, 10):
+            def __or__(self, right: Any) -> _SpecialForm: ...
+            def __ror__(self, left: Any) -> _SpecialForm: ...
+
+    @runtime_checkable
+    class Buffer(Protocol):
+        # Not actually a Protocol at runtime; see
+        # https://github.com/python/typeshed/issues/10224 for why we're defining it this way
+        def __buffer__(self, __flags: int) -> memoryview: ...
diff --git a/mypy/typeshed/stdlib/weakref.pyi b/mypy/typeshed/stdlib/weakref.pyi
index 0bbab52f9b086..13f48fe85a8d4 100644
--- a/mypy/typeshed/stdlib/weakref.pyi
+++ b/mypy/typeshed/stdlib/weakref.pyi
@@ -41,7 +41,7 @@ _P = ParamSpec("_P")
 ProxyTypes: tuple[type[Any], ...]
 
 class WeakMethod(ref[_CallableT], Generic[_CallableT]):
-    def __new__(cls, meth: _CallableT, callback: Callable[[_CallableT], object] | None = None) -> Self: ...
+    def __new__(cls, meth: _CallableT, callback: Callable[[Self], object] | None = None) -> Self: ...
     def __call__(self) -> _CallableT | None: ...
     def __eq__(self, other: object) -> bool: ...
     def __ne__(self, other: object) -> bool: ...
diff --git a/mypy/typeshed/stdlib/xmlrpc/client.pyi b/mypy/typeshed/stdlib/xmlrpc/client.pyi
index 8c32f3080749d..79969359f0910 100644
--- a/mypy/typeshed/stdlib/xmlrpc/client.pyi
+++ b/mypy/typeshed/stdlib/xmlrpc/client.pyi
@@ -2,7 +2,7 @@ import gzip
 import http.client
 import sys
 import time
-from _typeshed import ReadableBuffer, SupportsRead, SupportsWrite, _BufferWithLen
+from _typeshed import ReadableBuffer, SizedBuffer, SupportsRead, SupportsWrite
 from collections.abc import Callable, Iterable, Mapping
 from datetime import datetime
 from io import BytesIO
@@ -236,20 +236,20 @@ class Transport:
         def __init__(self, use_datetime: bool = False, use_builtin_types: bool = False) -> None: ...
 
     def request(
-        self, host: _HostType, handler: str, request_body: _BufferWithLen, verbose: bool = False
+        self, host: _HostType, handler: str, request_body: SizedBuffer, verbose: bool = False
     ) -> tuple[_Marshallable, ...]: ...
     def single_request(
-        self, host: _HostType, handler: str, request_body: _BufferWithLen, verbose: bool = False
+        self, host: _HostType, handler: str, request_body: SizedBuffer, verbose: bool = False
     ) -> tuple[_Marshallable, ...]: ...
     def getparser(self) -> tuple[ExpatParser, Unmarshaller]: ...
     def get_host_info(self, host: _HostType) -> tuple[str, list[tuple[str, str]], dict[str, str]]: ...
     def make_connection(self, host: _HostType) -> http.client.HTTPConnection: ...
     def close(self) -> None: ...
     def send_request(
-        self, host: _HostType, handler: str, request_body: _BufferWithLen, debug: bool
+        self, host: _HostType, handler: str, request_body: SizedBuffer, debug: bool
     ) -> http.client.HTTPConnection: ...
     def send_headers(self, connection: http.client.HTTPConnection, headers: list[tuple[str, str]]) -> None: ...
-    def send_content(self, connection: http.client.HTTPConnection, request_body: _BufferWithLen) -> None: ...
+    def send_content(self, connection: http.client.HTTPConnection, request_body: SizedBuffer) -> None: ...
     def parse_response(self, response: http.client.HTTPResponse) -> tuple[_Marshallable, ...]: ...
 
 class SafeTransport(Transport):
diff --git a/mypy/typeshed/stdlib/zipfile.pyi b/mypy/typeshed/stdlib/zipfile.pyi
index 92f1dc49adbcd..abda7a3b96257 100644
--- a/mypy/typeshed/stdlib/zipfile.pyi
+++ b/mypy/typeshed/stdlib/zipfile.pyi
@@ -1,6 +1,6 @@
 import io
 import sys
-from _typeshed import StrOrBytesPath, StrPath, _BufferWithLen
+from _typeshed import SizedBuffer, StrOrBytesPath, StrPath
 from collections.abc import Callable, Iterable, Iterator
 from os import PathLike
 from types import TracebackType
@@ -179,7 +179,7 @@ class ZipFile:
     def writestr(
         self,
         zinfo_or_arcname: str | ZipInfo,
-        data: _BufferWithLen | str,
+        data: SizedBuffer | str,
         compress_type: int | None = None,
         compresslevel: int | None = None,
     ) -> None: ...
diff --git a/test-data/unit/pythoneval.test b/test-data/unit/pythoneval.test
index 760a761705f48..7108734102d12 100644
--- a/test-data/unit/pythoneval.test
+++ b/test-data/unit/pythoneval.test
@@ -1019,7 +1019,7 @@ re.subn(bpat, lambda m: b'', b'')[0] + b''
 _testReModuleBytes.py:7: error: No overload variant of "search" matches argument types "bytes", "str"
 _testReModuleBytes.py:7: note: Possible overload variants:
 _testReModuleBytes.py:7: note:     def search(pattern: Union[str, Pattern[str]], string: str, flags: Union[int, RegexFlag] = ...) -> Optional[Match[str]]
-_testReModuleBytes.py:7: note:     def search(pattern: Union[bytes, Pattern[bytes]], string: Union[bytes, Union[bytearray, memoryview, array[Any], mmap, _CData]], flags: Union[int, RegexFlag] = ...) -> Optional[Match[bytes]]
+_testReModuleBytes.py:7: note:     def search(pattern: Union[bytes, Pattern[bytes]], string: Buffer, flags: Union[int, RegexFlag] = ...) -> Optional[Match[bytes]]
 _testReModuleBytes.py:9: error: Argument 1 to "search" has incompatible type "Pattern[bytes]"; expected "Union[str, Pattern[str]]"
 
 [case testReModuleString]
@@ -1046,7 +1046,7 @@ re.subn(spat, lambda m: '', '')[0] + ''
 _testReModuleString.py:7: error: No overload variant of "search" matches argument types "str", "bytes"
 _testReModuleString.py:7: note: Possible overload variants:
 _testReModuleString.py:7: note:     def search(pattern: Union[str, Pattern[str]], string: str, flags: Union[int, RegexFlag] = ...) -> Optional[Match[str]]
-_testReModuleString.py:7: note:     def search(pattern: Union[bytes, Pattern[bytes]], string: Union[bytes, Union[bytearray, memoryview, array[Any], mmap, _CData]], flags: Union[int, RegexFlag] = ...) -> Optional[Match[bytes]]
+_testReModuleString.py:7: note:     def search(pattern: Union[bytes, Pattern[bytes]], string: Buffer, flags: Union[int, RegexFlag] = ...) -> Optional[Match[bytes]]
 _testReModuleString.py:9: error: Argument 1 to "search" has incompatible type "Pattern[str]"; expected "Union[bytes, Pattern[bytes]]"
 
 [case testListSetitemTuple]

From c0af000d068b30362c4f4f72b8823e4f3f5b3e08 Mon Sep 17 00:00:00 2001
From: Ilya Priven <ilya.konstantinov@gmail.com>
Date: Thu, 1 Jun 2023 01:02:05 -0400
Subject: [PATCH 004/129] --update-data should not touch xfail tests (#15337)

---
 mypy/test/testupdatedata.py | 6 ++++++
 mypy/test/update_data.py    | 2 ++
 2 files changed, 8 insertions(+)

diff --git a/mypy/test/testupdatedata.py b/mypy/test/testupdatedata.py
index 2e86c641ce6d3..2a6d2462f10c0 100644
--- a/mypy/test/testupdatedata.py
+++ b/mypy/test/testupdatedata.py
@@ -46,6 +46,9 @@ def test_update_data(self) -> None:
             [case testWrong]
             s: str = 42  # E: wrong error
 
+            [case testXfail-xfail]
+            s: str = 42  # E: wrong error
+
             [case testWrongMultiline]
             s: str = 42  # E: foo \
                          # N: bar
@@ -101,6 +104,9 @@ def test_update_data(self) -> None:
         [case testWrong]
         s: str = 42  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
 
+        [case testXfail-xfail]
+        s: str = 42  # E: wrong error
+
         [case testWrongMultiline]
         s: str = 42  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
 
diff --git a/mypy/test/update_data.py b/mypy/test/update_data.py
index b37b440de38f6..2d66752f61bd7 100644
--- a/mypy/test/update_data.py
+++ b/mypy/test/update_data.py
@@ -10,6 +10,8 @@
 def update_testcase_output(
     testcase: DataDrivenTestCase, actual: list[str], *, incremental_step: int
 ) -> None:
+    if testcase.xfail:
+        return
     collector = testcase.parent
     assert isinstance(collector, DataFileCollector)
     for fix in _iter_fixes(testcase, actual, incremental_step=incremental_step):

From c4f55aefb17d3c12f036f2cc99ac7cc89f252915 Mon Sep 17 00:00:00 2001
From: Logan Hunt <39638017+dosisod@users.noreply.github.com>
Date: Fri, 2 Jun 2023 06:51:25 -0700
Subject: [PATCH 005/129] [mypyc] Inline math literals (#15324)

This PR inlines math literals such as `math.pi` and `math.e`. Previously
Using `math.pi` would emit a getattr, unbox, error check, then box op
code (if we need a boxed value), but now it just generates a literal directly
(that is sometimes boxed).

Closes https://github.com/mypyc/mypyc/issues/985
---
 mypyc/codegen/emitfunc.py         |  2 +
 mypyc/codegen/literals.py         |  2 +
 mypyc/irbuild/builder.py          |  3 ++
 mypyc/irbuild/expression.py       | 24 ++++++++++++
 mypyc/test-data/irbuild-math.test | 64 +++++++++++++++++++++++++++++++
 mypyc/test-data/run-math.test     | 18 +++++++++
 mypyc/test/test_irbuild.py        |  1 +
 test-data/unit/lib-stub/math.pyi  |  4 ++
 8 files changed, 118 insertions(+)
 create mode 100644 mypyc/test-data/irbuild-math.test

diff --git a/mypyc/codegen/emitfunc.py b/mypyc/codegen/emitfunc.py
index bcd5fac45f94f..7e6d775d74b4d 100644
--- a/mypyc/codegen/emitfunc.py
+++ b/mypyc/codegen/emitfunc.py
@@ -775,6 +775,8 @@ def reg(self, reg: Value) -> str:
                 return "INFINITY"
             elif r == "-inf":
                 return "-INFINITY"
+            elif r == "nan":
+                return "NAN"
             return r
         else:
             return self.emitter.reg(reg)
diff --git a/mypyc/codegen/literals.py b/mypyc/codegen/literals.py
index d8fd115be99e4..8f84089221c3e 100644
--- a/mypyc/codegen/literals.py
+++ b/mypyc/codegen/literals.py
@@ -265,6 +265,8 @@ def float_to_c(x: float) -> str:
         return "INFINITY"
     elif s == "-inf":
         return "-INFINITY"
+    elif s == "nan":
+        return "NAN"
     return s
 
 
diff --git a/mypyc/irbuild/builder.py b/mypyc/irbuild/builder.py
index f071cc20f6b64..890a6f2f16f35 100644
--- a/mypyc/irbuild/builder.py
+++ b/mypyc/irbuild/builder.py
@@ -301,6 +301,9 @@ def load_bytes_from_str_literal(self, value: str) -> Value:
     def load_int(self, value: int) -> Value:
         return self.builder.load_int(value)
 
+    def load_float(self, value: float) -> Value:
+        return self.builder.load_float(value)
+
     def unary_op(self, lreg: Value, expr_op: str, line: int) -> Value:
         return self.builder.unary_op(lreg, expr_op, line)
 
diff --git a/mypyc/irbuild/expression.py b/mypyc/irbuild/expression.py
index 30537777fcc18..4ebc422ed535d 100644
--- a/mypyc/irbuild/expression.py
+++ b/mypyc/irbuild/expression.py
@@ -6,6 +6,7 @@
 
 from __future__ import annotations
 
+import math
 from typing import Callable, Sequence
 
 from mypy.nodes import (
@@ -128,6 +129,10 @@ def transform_name_expr(builder: IRBuilder, expr: NameExpr) -> Value:
     if fullname == "builtins.False":
         return builder.false()
 
+    math_literal = transform_math_literal(builder, fullname)
+    if math_literal is not None:
+        return math_literal
+
     if isinstance(expr.node, Var) and expr.node.is_final:
         value = builder.emit_load_final(
             expr.node,
@@ -192,6 +197,10 @@ def transform_member_expr(builder: IRBuilder, expr: MemberExpr) -> Value:
         if value is not None:
             return value
 
+    math_literal = transform_math_literal(builder, expr.fullname)
+    if math_literal is not None:
+        return math_literal
+
     if isinstance(expr.node, MypyFile) and expr.node.fullname in builder.imports:
         return builder.load_module(expr.node.fullname)
 
@@ -1043,3 +1052,18 @@ def transform_assignment_expr(builder: IRBuilder, o: AssignmentExpr) -> Value:
     target = builder.get_assignment_target(o.target)
     builder.assign(target, value, o.line)
     return value
+
+
+def transform_math_literal(builder: IRBuilder, fullname: str) -> Value | None:
+    if fullname == "math.e":
+        return builder.load_float(math.e)
+    if fullname == "math.pi":
+        return builder.load_float(math.pi)
+    if fullname == "math.inf":
+        return builder.load_float(math.inf)
+    if fullname == "math.nan":
+        return builder.load_float(math.nan)
+    if fullname == "math.tau":
+        return builder.load_float(math.tau)
+
+    return None
diff --git a/mypyc/test-data/irbuild-math.test b/mypyc/test-data/irbuild-math.test
new file mode 100644
index 0000000000000..470e60c74f7df
--- /dev/null
+++ b/mypyc/test-data/irbuild-math.test
@@ -0,0 +1,64 @@
+[case testMathLiteralsAreInlined]
+import math
+from math import pi, e, tau, inf, nan
+
+def f1() -> float:
+    return pi
+
+def f2() -> float:
+    return math.pi
+
+def f3() -> float:
+    return math.e
+
+def f4() -> float:
+    return math.e
+
+def f5() -> float:
+    return math.tau
+
+def f6() -> float:
+    return math.tau
+
+def f7() -> float:
+    return math.inf
+def f8() -> float:
+    return math.inf
+
+def f9() -> float:
+    return math.nan
+
+def f10() -> float:
+    return math.nan
+
+[out]
+def f1():
+L0:
+    return 3.141592653589793
+def f2():
+L0:
+    return 3.141592653589793
+def f3():
+L0:
+    return 2.718281828459045
+def f4():
+L0:
+    return 2.718281828459045
+def f5():
+L0:
+    return 6.283185307179586
+def f6():
+L0:
+    return 6.283185307179586
+def f7():
+L0:
+    return inf
+def f8():
+L0:
+    return inf
+def f9():
+L0:
+    return nan
+def f10():
+L0:
+    return nan
diff --git a/mypyc/test-data/run-math.test b/mypyc/test-data/run-math.test
index 64d5c1812afad..266b4851575f3 100644
--- a/mypyc/test-data/run-math.test
+++ b/mypyc/test-data/run-math.test
@@ -4,6 +4,7 @@
 from typing import Any, Callable
 from typing_extensions import Final
 import math
+from math import pi, e, tau, inf, nan
 from testutil import assertRaises, float_vals, assertDomainError, assertMathRangeError
 
 pymath: Any = math
@@ -86,3 +87,20 @@ def test_isinf() -> None:
 def test_isnan() -> None:
     for x in float_vals:
         assert repr(math.isnan(x)) == repr(pymath.isnan(x))
+
+
+def test_pi_is_inlined_correctly() -> None:
+    assert math.pi == pi == 3.141592653589793
+
+def test_e_is_inlined_correctly() -> None:
+    assert math.e == e == 2.718281828459045
+
+def test_tau_is_inlined_correctly() -> None:
+    assert math.tau == tau == 6.283185307179586
+
+def test_inf_is_inlined_correctly() -> None:
+    assert math.inf == inf == float("inf")
+
+def test_nan_is_inlined_correctly() -> None:
+    assert math.isnan(math.nan)
+    assert math.isnan(nan)
diff --git a/mypyc/test/test_irbuild.py b/mypyc/test/test_irbuild.py
index 86bdf7c590d8f..fe347c855661d 100644
--- a/mypyc/test/test_irbuild.py
+++ b/mypyc/test/test_irbuild.py
@@ -49,6 +49,7 @@
     "irbuild-singledispatch.test",
     "irbuild-constant-fold.test",
     "irbuild-glue-methods.test",
+    "irbuild-math.test",
 ]
 
 if sys.version_info >= (3, 10):
diff --git a/test-data/unit/lib-stub/math.pyi b/test-data/unit/lib-stub/math.pyi
index 587b04a56de83..06f8878a563e9 100644
--- a/test-data/unit/lib-stub/math.pyi
+++ b/test-data/unit/lib-stub/math.pyi
@@ -1,4 +1,8 @@
 pi: float
+e: float
+tau: float
+inf: float
+nan: float
 def sqrt(__x: float) -> float: ...
 def sin(__x: float) -> float: ...
 def cos(__x: float) -> float: ...

From f8f9453083c416237247a6596692c8d2b42adc78 Mon Sep 17 00:00:00 2001
From: Richard Si <sichard26@gmail.com>
Date: Fri, 2 Jun 2023 10:29:41 -0400
Subject: [PATCH 006/129] [mypyc] Use correct rtype for variable with inferred
 optional type (#15206)

```python
def f(b: bool) -> None:
    if b:
        y = 1
    else:
        y = None

f(False)
```

On encountering y = 1, mypyc uses the expression type to determine the
variable rtype. This usually works (as mypy infers the variable type
based on the first assignment and doesn't let it change afterwards),
except in this situation.

NameExpr(y)'s type is int, but the variable should really be int | None.
Fortunately, we can use the Var node's type information which is
correct... instead of blindly assuming the first assignment's type is
right.

Fixes mypyc/mypyc#964
---
 mypyc/irbuild/builder.py      | 12 +++++++-----
 mypyc/test-data/run-misc.test | 30 ++++++++++++++++++++++++++++++
 2 files changed, 37 insertions(+), 5 deletions(-)

diff --git a/mypyc/irbuild/builder.py b/mypyc/irbuild/builder.py
index 890a6f2f16f35..26aa17071974f 100644
--- a/mypyc/irbuild/builder.py
+++ b/mypyc/irbuild/builder.py
@@ -48,6 +48,7 @@
 )
 from mypy.types import (
     AnyType,
+    DeletedType,
     Instance,
     ProperType,
     TupleType,
@@ -573,6 +574,10 @@ def get_assignment_target(
                 self.error("Cannot assign to the first argument of classmethod", line)
             if lvalue.kind == LDEF:
                 if symbol not in self.symtables[-1]:
+                    if isinstance(symbol, Var) and not isinstance(symbol.type, DeletedType):
+                        reg_type = self.type_to_rtype(symbol.type)
+                    else:
+                        reg_type = self.node_type(lvalue)
                     # If the function is a generator function, then first define a new variable
                     # in the current function's environment class. Next, define a target that
                     # refers to the newly defined variable in that environment class. Add the
@@ -580,14 +585,11 @@ def get_assignment_target(
                     # current environment.
                     if self.fn_info.is_generator:
                         return self.add_var_to_env_class(
-                            symbol,
-                            self.node_type(lvalue),
-                            self.fn_info.generator_class,
-                            reassign=False,
+                            symbol, reg_type, self.fn_info.generator_class, reassign=False
                         )
 
                     # Otherwise define a new local variable.
-                    return self.add_local_reg(symbol, self.node_type(lvalue))
+                    return self.add_local_reg(symbol, reg_type)
                 else:
                     # Assign to a previously defined variable.
                     return self.lookup(symbol)
diff --git a/mypyc/test-data/run-misc.test b/mypyc/test-data/run-misc.test
index 33f23ea3e9430..fd0eb5022236d 100644
--- a/mypyc/test-data/run-misc.test
+++ b/mypyc/test-data/run-misc.test
@@ -84,6 +84,36 @@ assert f(a) is a
 assert g(None) == 1
 assert g(a) == 2
 
+[case testInferredOptionalAssignment]
+from typing import Any, Generator
+
+def f(b: bool) -> Any:
+    if b:
+        x = None
+    else:
+        x = 1
+
+    if b:
+        y = 1
+    else:
+        y = None
+
+    m = 1 if b else None
+    n = None if b else 1
+    return ((x, y), (m, n))
+
+def gen(b: bool) -> Generator[Any, None, None]:
+    if b:
+        y = 1
+    else:
+        y = None
+    yield y
+
+assert f(False) == ((1, None), (None, 1))
+assert f(True) == ((None, 1), (1, None))
+assert next(gen(False)) is None
+assert next(gen(True)) == 1
+
 [case testWith]
 from typing import Any
 class Thing:

From 21c5439dccfc6fc21f126200b95b0552f503d5da Mon Sep 17 00:00:00 2001
From: yaegassy <yaegassy@users.noreply.github.com>
Date: Sat, 3 Jun 2023 05:40:08 +0900
Subject: [PATCH 007/129] fix(docs): bool -> boolean in config_file.rst
 (#15352)

---
 docs/source/config_file.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/source/config_file.rst b/docs/source/config_file.rst
index b5ce1b0c11718..9e79ff99937b6 100644
--- a/docs/source/config_file.rst
+++ b/docs/source/config_file.rst
@@ -366,7 +366,7 @@ section of the command line docs.
 
 .. confval:: no_site_packages
 
-    :type: bool
+    :type: boolean
     :default: False
 
     Disables using type information in installed packages (see :pep:`561`).

From 66bd2c441277b29b1454e26b2a3454a0dae5fb18 Mon Sep 17 00:00:00 2001
From: Nikita Sobolev <mail@sobolevn.me>
Date: Mon, 5 Jun 2023 10:21:11 +0300
Subject: [PATCH 008/129] Do not block on duplicate base classes (#15367)

Continue type checking if a class has two or more identical bases.
Closes https://github.com/python/mypy/issues/15349

---------

Co-authored-by: hauntsaninja <hauntsaninja@gmail.com>
---
 mypy/semanal.py                   | 19 +++++++++++++++----
 test-data/unit/check-classes.test | 31 +++++++++++++++++++++++++------
 2 files changed, 40 insertions(+), 10 deletions(-)

diff --git a/mypy/semanal.py b/mypy/semanal.py
index 8934dc9321b75..3ca758ad4eb19 100644
--- a/mypy/semanal.py
+++ b/mypy/semanal.py
@@ -2189,6 +2189,10 @@ def configure_base_classes(
         if not self.verify_base_classes(defn):
             self.set_dummy_mro(defn.info)
             return
+        if not self.verify_duplicate_base_classes(defn):
+            # We don't want to block the typechecking process,
+            # so, we just insert `Any` as the base class and show an error.
+            self.set_any_mro(defn.info)
         self.calculate_class_mro(defn, self.object_type)
 
     def configure_tuple_base_class(self, defn: ClassDef, base: TupleType) -> Instance:
@@ -2218,6 +2222,11 @@ def set_dummy_mro(self, info: TypeInfo) -> None:
         info.mro = [info, self.object_type().type]
         info.bad_mro = True
 
+    def set_any_mro(self, info: TypeInfo) -> None:
+        # Give it an MRO consisting direct `Any` subclass.
+        info.fallback_to_any = True
+        info.mro = [info, self.object_type().type]
+
     def calculate_class_mro(
         self, defn: ClassDef, obj_type: Callable[[], Instance] | None = None
     ) -> None:
@@ -2298,12 +2307,14 @@ def verify_base_classes(self, defn: ClassDef) -> bool:
             if self.is_base_class(info, baseinfo):
                 self.fail("Cycle in inheritance hierarchy", defn)
                 cycle = True
-        dup = find_duplicate(info.direct_base_classes())
-        if dup:
-            self.fail(f'Duplicate base class "{dup.name}"', defn, blocker=True)
-            return False
         return not cycle
 
+    def verify_duplicate_base_classes(self, defn: ClassDef) -> bool:
+        dup = find_duplicate(defn.info.direct_base_classes())
+        if dup:
+            self.fail(f'Duplicate base class "{dup.name}"', defn)
+        return not dup
+
     def is_base_class(self, t: TypeInfo, s: TypeInfo) -> bool:
         """Determine if t is a base class of s (but do not use mro)."""
         # Search the base class graph for t, starting from s.
diff --git a/test-data/unit/check-classes.test b/test-data/unit/check-classes.test
index 3af20bd1e7eac..c2eddbc597a0a 100644
--- a/test-data/unit/check-classes.test
+++ b/test-data/unit/check-classes.test
@@ -4124,12 +4124,31 @@ int.__eq__(3, 4)
 main:33: error: Too few arguments for "__eq__" of "int"
 main:33: error: Unsupported operand types for == ("int" and "Type[int]")
 
-[case testMroSetAfterError]
-class C(str, str):
-    foo = 0
-    bar = foo
-[out]
-main:1: error: Duplicate base class "str"
+[case testDupBaseClasses]
+class A:
+    def method(self) -> str: ...
+
+class B(A, A):  # E: Duplicate base class "A"
+    attr: int
+
+b: B
+
+reveal_type(b.method())  # N: Revealed type is "Any"
+reveal_type(b.missing())  # N: Revealed type is "Any"
+reveal_type(b.attr)  # N: Revealed type is "builtins.int"
+
+[case testDupBaseClassesGeneric]
+from typing import Generic, TypeVar
+
+T = TypeVar('T')
+class A(Generic[T]):
+    def method(self) -> T: ...
+
+class B(A[int], A[str]):  # E: Duplicate base class "A"
+    attr: int
+
+reveal_type(B().method())  # N: Revealed type is "Any"
+reveal_type(B().attr)   # N: Revealed type is "builtins.int"
 
 [case testCannotDetermineMro]
 class A: pass

From 8409b884e97de82bc1638dc91ca26b85d06f3de2 Mon Sep 17 00:00:00 2001
From: Ilya Priven <ilya.konstantinov@gmail.com>
Date: Tue, 6 Jun 2023 11:57:25 -0400
Subject: [PATCH 009/129] testupdatedata: fix cwd (#15383)

This should allow the inner pytest to pass even when the outer pytest is
invoked outside of the mypy root, e.g.
```shell
cd ..
pytest mypy/mypy/test/testupdatedata.py
```

Addresses
https://github.com/python/mypy/pull/15283#issuecomment-1578609223.
---
 mypy/test/testupdatedata.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/mypy/test/testupdatedata.py b/mypy/test/testupdatedata.py
index 2a6d2462f10c0..54e9622a5e916 100644
--- a/mypy/test/testupdatedata.py
+++ b/mypy/test/testupdatedata.py
@@ -14,7 +14,9 @@ def _run_pytest_update_data(self, data_suite: str, *, max_attempts: int) -> str:
         Runs a suite of data test cases through 'pytest --update-data' until either tests pass
         or until a maximum number of attempts (needed for incremental tests).
         """
-        p = Path(test_data_prefix) / "check-update-data.test"
+        p_test_data = Path(test_data_prefix)
+        p_root = p_test_data.parent.parent
+        p = p_test_data / "check-update-data.test"
         assert not p.exists()
         try:
             p.write_text(textwrap.dedent(data_suite).lstrip())
@@ -26,7 +28,7 @@ def _run_pytest_update_data(self, data_suite: str, *, max_attempts: int) -> str:
             else:
                 cmd = " ".join(args)
             for i in range(max_attempts - 1, -1, -1):
-                res = subprocess.run(args)
+                res = subprocess.run(args, cwd=p_root)
                 if res.returncode == 0:
                     break
                 print(f"`{cmd}` returned {res.returncode}: {i} attempts remaining")

From 2ab8849f6460fe586a1a1add3a006ce4edd3fb75 Mon Sep 17 00:00:00 2001
From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
Date: Wed, 7 Jun 2023 01:40:57 +0200
Subject: [PATCH 010/129] Update semantic analyzer for TypeVar defaults (PEP
 696) (#14873)

This PR updates the semantic analyzer to support most forms of TypeVars
with defaults while also providing basic argument validation.

Ref: #14851
---
 mypy/message_registry.py                      |   2 +-
 mypy/semanal.py                               | 152 ++++++++++++++----
 mypy/types.py                                 |  22 ++-
 .../unit/check-parameter-specification.test   |  10 +-
 test-data/unit/check-typevar-defaults.test    |  74 +++++++++
 test-data/unit/semanal-errors.test            |   3 +-
 6 files changed, 224 insertions(+), 39 deletions(-)
 create mode 100644 test-data/unit/check-typevar-defaults.test

diff --git a/mypy/message_registry.py b/mypy/message_registry.py
index 776d0bfef2138..c5164d48fd130 100644
--- a/mypy/message_registry.py
+++ b/mypy/message_registry.py
@@ -181,7 +181,7 @@ def with_additional_msg(self, info: str) -> ErrorMessage:
 INVALID_TYPEVAR_ARG_BOUND: Final = 'Type argument {} of "{}" must be a subtype of {}'
 INVALID_TYPEVAR_ARG_VALUE: Final = 'Invalid type argument value for "{}"'
 TYPEVAR_VARIANCE_DEF: Final = 'TypeVar "{}" may only be a literal bool'
-TYPEVAR_BOUND_MUST_BE_TYPE: Final = 'TypeVar "bound" must be a type'
+TYPEVAR_ARG_MUST_BE_TYPE: Final = '{} "{}" must be a type'
 TYPEVAR_UNEXPECTED_ARGUMENT: Final = 'Unexpected argument to "TypeVar()"'
 UNBOUND_TYPEVAR: Final = (
     "A function returning TypeVar should receive at least "
diff --git a/mypy/semanal.py b/mypy/semanal.py
index 3ca758ad4eb19..c5a6989f4f61b 100644
--- a/mypy/semanal.py
+++ b/mypy/semanal.py
@@ -4135,28 +4135,15 @@ def process_typevar_parameters(
                 if has_values:
                     self.fail("TypeVar cannot have both values and an upper bound", context)
                     return None
-                try:
-                    # We want to use our custom error message below, so we suppress
-                    # the default error message for invalid types here.
-                    analyzed = self.expr_to_analyzed_type(
-                        param_value, allow_placeholder=True, report_invalid_types=False
-                    )
-                    if analyzed is None:
-                        # Type variables are special: we need to place them in the symbol table
-                        # soon, even if upper bound is not ready yet. Otherwise avoiding
-                        # a "deadlock" in this common pattern would be tricky:
-                        #     T = TypeVar('T', bound=Custom[Any])
-                        #     class Custom(Generic[T]):
-                        #         ...
-                        analyzed = PlaceholderType(None, [], context.line)
-                    upper_bound = get_proper_type(analyzed)
-                    if isinstance(upper_bound, AnyType) and upper_bound.is_from_error:
-                        self.fail(message_registry.TYPEVAR_BOUND_MUST_BE_TYPE, param_value)
-                        # Note: we do not return 'None' here -- we want to continue
-                        # using the AnyType as the upper bound.
-                except TypeTranslationError:
-                    self.fail(message_registry.TYPEVAR_BOUND_MUST_BE_TYPE, param_value)
+                tv_arg = self.get_typevarlike_argument("TypeVar", param_name, param_value, context)
+                if tv_arg is None:
                     return None
+                upper_bound = tv_arg
+            elif param_name == "default":
+                tv_arg = self.get_typevarlike_argument(
+                    "TypeVar", param_name, param_value, context, allow_unbound_tvars=True
+                )
+                default = tv_arg or AnyType(TypeOfAny.from_error)
             elif param_name == "values":
                 # Probably using obsolete syntax with values=(...). Explain the current syntax.
                 self.fail('TypeVar "values" argument not supported', context)
@@ -4184,6 +4171,52 @@ def process_typevar_parameters(
             variance = INVARIANT
         return variance, upper_bound, default
 
+    def get_typevarlike_argument(
+        self,
+        typevarlike_name: str,
+        param_name: str,
+        param_value: Expression,
+        context: Context,
+        *,
+        allow_unbound_tvars: bool = False,
+        allow_param_spec_literals: bool = False,
+        report_invalid_typevar_arg: bool = True,
+    ) -> ProperType | None:
+        try:
+            # We want to use our custom error message below, so we suppress
+            # the default error message for invalid types here.
+            analyzed = self.expr_to_analyzed_type(
+                param_value,
+                allow_placeholder=True,
+                report_invalid_types=False,
+                allow_unbound_tvars=allow_unbound_tvars,
+                allow_param_spec_literals=allow_param_spec_literals,
+            )
+            if analyzed is None:
+                # Type variables are special: we need to place them in the symbol table
+                # soon, even if upper bound is not ready yet. Otherwise avoiding
+                # a "deadlock" in this common pattern would be tricky:
+                #     T = TypeVar('T', bound=Custom[Any])
+                #     class Custom(Generic[T]):
+                #         ...
+                analyzed = PlaceholderType(None, [], context.line)
+            typ = get_proper_type(analyzed)
+            if report_invalid_typevar_arg and isinstance(typ, AnyType) and typ.is_from_error:
+                self.fail(
+                    message_registry.TYPEVAR_ARG_MUST_BE_TYPE.format(typevarlike_name, param_name),
+                    param_value,
+                )
+                # Note: we do not return 'None' here -- we want to continue
+                # using the AnyType.
+            return typ
+        except TypeTranslationError:
+            if report_invalid_typevar_arg:
+                self.fail(
+                    message_registry.TYPEVAR_ARG_MUST_BE_TYPE.format(typevarlike_name, param_name),
+                    param_value,
+                )
+            return None
+
     def extract_typevarlike_name(self, s: AssignmentStmt, call: CallExpr) -> str | None:
         if not call:
             return None
@@ -4216,13 +4249,50 @@ def process_paramspec_declaration(self, s: AssignmentStmt) -> bool:
         if name is None:
             return False
 
-        # ParamSpec is different from a regular TypeVar:
-        # arguments are not semantically valid. But, allowed in runtime.
-        # So, we need to warn users about possible invalid usage.
-        if len(call.args) > 1:
-            self.fail("Only the first argument to ParamSpec has defined semantics", s)
+        n_values = call.arg_kinds[1:].count(ARG_POS)
+        if n_values != 0:
+            self.fail('Too many positional arguments for "ParamSpec"', s)
 
         default: Type = AnyType(TypeOfAny.from_omitted_generics)
+        for param_value, param_name in zip(
+            call.args[1 + n_values :], call.arg_names[1 + n_values :]
+        ):
+            if param_name == "default":
+                tv_arg = self.get_typevarlike_argument(
+                    "ParamSpec",
+                    param_name,
+                    param_value,
+                    s,
+                    allow_unbound_tvars=True,
+                    allow_param_spec_literals=True,
+                    report_invalid_typevar_arg=False,
+                )
+                default = tv_arg or AnyType(TypeOfAny.from_error)
+                if isinstance(tv_arg, Parameters):
+                    for i, arg_type in enumerate(tv_arg.arg_types):
+                        typ = get_proper_type(arg_type)
+                        if isinstance(typ, AnyType) and typ.is_from_error:
+                            self.fail(
+                                f"Argument {i} of ParamSpec default must be a type", param_value
+                            )
+                elif (
+                    isinstance(default, AnyType)
+                    and default.is_from_error
+                    or not isinstance(default, (AnyType, UnboundType))
+                ):
+                    self.fail(
+                        "The default argument to ParamSpec must be a list expression, ellipsis, or a ParamSpec",
+                        param_value,
+                    )
+                    default = AnyType(TypeOfAny.from_error)
+            else:
+                # ParamSpec is different from a regular TypeVar:
+                # arguments are not semantically valid. But, allowed in runtime.
+                # So, we need to warn users about possible invalid usage.
+                self.fail(
+                    "The variance and bound arguments to ParamSpec do not have defined semantics yet",
+                    s,
+                )
 
         # PEP 612 reserves the right to define bound, covariant and contravariant arguments to
         # ParamSpec in a later PEP. If and when that happens, we should do something
@@ -4256,10 +4326,32 @@ def process_typevartuple_declaration(self, s: AssignmentStmt) -> bool:
         if not call:
             return False
 
-        if len(call.args) > 1:
-            self.fail("Only the first argument to TypeVarTuple has defined semantics", s)
+        n_values = call.arg_kinds[1:].count(ARG_POS)
+        if n_values != 0:
+            self.fail('Too many positional arguments for "TypeVarTuple"', s)
 
         default: Type = AnyType(TypeOfAny.from_omitted_generics)
+        for param_value, param_name in zip(
+            call.args[1 + n_values :], call.arg_names[1 + n_values :]
+        ):
+            if param_name == "default":
+                tv_arg = self.get_typevarlike_argument(
+                    "TypeVarTuple",
+                    param_name,
+                    param_value,
+                    s,
+                    allow_unbound_tvars=True,
+                    report_invalid_typevar_arg=False,
+                )
+                default = tv_arg or AnyType(TypeOfAny.from_error)
+                if not isinstance(default, UnpackType):
+                    self.fail(
+                        "The default argument to TypeVarTuple must be an Unpacked tuple",
+                        param_value,
+                    )
+                    default = AnyType(TypeOfAny.from_error)
+            else:
+                self.fail(f'Unexpected keyword argument "{param_name}" for "TypeVarTuple"', s)
 
         if not self.incomplete_feature_enabled(TYPE_VAR_TUPLE, s):
             return False
@@ -6359,6 +6451,8 @@ def expr_to_analyzed_type(
         report_invalid_types: bool = True,
         allow_placeholder: bool = False,
         allow_type_any: bool = False,
+        allow_unbound_tvars: bool = False,
+        allow_param_spec_literals: bool = False,
     ) -> Type | None:
         if isinstance(expr, CallExpr):
             # This is a legacy syntax intended mostly for Python 2, we keep it for
@@ -6387,6 +6481,8 @@ def expr_to_analyzed_type(
             report_invalid_types=report_invalid_types,
             allow_placeholder=allow_placeholder,
             allow_type_any=allow_type_any,
+            allow_unbound_tvars=allow_unbound_tvars,
+            allow_param_spec_literals=allow_param_spec_literals,
         )
 
     def analyze_type_expr(self, expr: Expression) -> None:
diff --git a/mypy/types.py b/mypy/types.py
index 53f21e8c02224..5fbdd385826c3 100644
--- a/mypy/types.py
+++ b/mypy/types.py
@@ -3049,6 +3049,8 @@ def visit_type_var(self, t: TypeVarType) -> str:
             s = f"{t.name}`{t.id}"
         if self.id_mapper and t.upper_bound:
             s += f"(upper_bound={t.upper_bound.accept(self)})"
+        if t.has_default():
+            s += f" = {t.default.accept(self)}"
         return s
 
     def visit_param_spec(self, t: ParamSpecType) -> str:
@@ -3064,6 +3066,8 @@ def visit_param_spec(self, t: ParamSpecType) -> str:
             s += f"{t.name_with_suffix()}`{t.id}"
         if t.prefix.arg_types:
             s += "]"
+        if t.has_default():
+            s += f" = {t.default.accept(self)}"
         return s
 
     def visit_parameters(self, t: Parameters) -> str:
@@ -3102,6 +3106,8 @@ def visit_type_var_tuple(self, t: TypeVarTupleType) -> str:
         else:
             # Named type variable type.
             s = f"{t.name}`{t.id}"
+        if t.has_default():
+            s += f" = {t.default.accept(self)}"
         return s
 
     def visit_callable_type(self, t: CallableType) -> str:
@@ -3138,6 +3144,8 @@ def visit_callable_type(self, t: CallableType) -> str:
             if s:
                 s += ", "
             s += f"*{n}.args, **{n}.kwargs"
+            if param_spec.has_default():
+                s += f" = {param_spec.default.accept(self)}"
 
         s = f"({s})"
 
@@ -3156,12 +3164,18 @@ def visit_callable_type(self, t: CallableType) -> str:
                         vals = f"({', '.join(val.accept(self) for val in var.values)})"
                         vs.append(f"{var.name} in {vals}")
                     elif not is_named_instance(var.upper_bound, "builtins.object"):
-                        vs.append(f"{var.name} <: {var.upper_bound.accept(self)}")
+                        vs.append(
+                            f"{var.name} <: {var.upper_bound.accept(self)}{f' = {var.default.accept(self)}' if var.has_default() else ''}"
+                        )
                     else:
-                        vs.append(var.name)
+                        vs.append(
+                            f"{var.name}{f' = {var.default.accept(self)}' if var.has_default()  else ''}"
+                        )
                 else:
-                    # For other TypeVarLikeTypes, just use the name
-                    vs.append(var.name)
+                    # For other TypeVarLikeTypes, use the name and default
+                    vs.append(
+                        f"{var.name}{f' = {var.default.accept(self)}' if var.has_default() else ''}"
+                    )
             s = f"[{', '.join(vs)}] {s}"
 
         return f"def {s}"
diff --git a/test-data/unit/check-parameter-specification.test b/test-data/unit/check-parameter-specification.test
index fe66b18fbfea6..901e73008d563 100644
--- a/test-data/unit/check-parameter-specification.test
+++ b/test-data/unit/check-parameter-specification.test
@@ -6,11 +6,11 @@ P = ParamSpec('P')
 [case testInvalidParamSpecDefinitions]
 from typing import ParamSpec
 
-P1 = ParamSpec("P1", covariant=True)  # E: Only the first argument to ParamSpec has defined semantics
-P2 = ParamSpec("P2", contravariant=True)  # E: Only the first argument to ParamSpec has defined semantics
-P3 = ParamSpec("P3", bound=int)  # E: Only the first argument to ParamSpec has defined semantics
-P4 = ParamSpec("P4", int, str)  # E: Only the first argument to ParamSpec has defined semantics
-P5 = ParamSpec("P5", covariant=True, bound=int)  # E: Only the first argument to ParamSpec has defined semantics
+P1 = ParamSpec("P1", covariant=True)  # E: The variance and bound arguments to ParamSpec do not have defined semantics yet
+P2 = ParamSpec("P2", contravariant=True)  # E: The variance and bound arguments to ParamSpec do not have defined semantics yet
+P3 = ParamSpec("P3", bound=int)  # E: The variance and bound arguments to ParamSpec do not have defined semantics yet
+P4 = ParamSpec("P4", int, str)  # E: Too many positional arguments for "ParamSpec"
+P5 = ParamSpec("P5", covariant=True, bound=int)  # E: The variance and bound arguments to ParamSpec do not have defined semantics yet
 [builtins fixtures/paramspec.pyi]
 
 [case testParamSpecLocations]
diff --git a/test-data/unit/check-typevar-defaults.test b/test-data/unit/check-typevar-defaults.test
new file mode 100644
index 0000000000000..7bc2d4089ecd9
--- /dev/null
+++ b/test-data/unit/check-typevar-defaults.test
@@ -0,0 +1,74 @@
+[case testTypeVarDefaultsBasic]
+import builtins
+from typing import Generic, TypeVar, ParamSpec, Callable, Tuple, List
+from typing_extensions import TypeVarTuple, Unpack
+
+T1 = TypeVar("T1", default=int)
+P1 = ParamSpec("P1", default=[int, str])
+Ts1 = TypeVarTuple("Ts1", default=Unpack[Tuple[int, str]])
+
+def f1(a: T1) -> List[T1]: ...
+reveal_type(f1)  # N: Revealed type is "def [T1 = builtins.int] (a: T1`-1 = builtins.int) -> builtins.list[T1`-1 = builtins.int]"
+
+def f2(a: Callable[P1, None] ) -> Callable[P1, None]: ...
+reveal_type(f2)  # N: Revealed type is "def [P1 = [builtins.int, builtins.str]] (a: def (*P1.args, **P1.kwargs)) -> def (*P1.args, **P1.kwargs)"
+
+def f3(a: Tuple[Unpack[Ts1]]) -> Tuple[Unpack[Ts1]]: ...
+reveal_type(f3)  # N: Revealed type is "def [Ts1 = Unpack[Tuple[builtins.int, builtins.str]]] (a: Tuple[Unpack[Ts1`-1 = Unpack[Tuple[builtins.int, builtins.str]]]]) -> Tuple[Unpack[Ts1`-1 = Unpack[Tuple[builtins.int, builtins.str]]]]"
+
+
+class ClassA1(Generic[T1]): ...
+class ClassA2(Generic[P1]): ...
+class ClassA3(Generic[Unpack[Ts1]]): ...
+
+reveal_type(ClassA1)  # N: Revealed type is "def [T1 = builtins.int] () -> __main__.ClassA1[T1`1 = builtins.int]"
+reveal_type(ClassA2)  # N: Revealed type is "def [P1 = [builtins.int, builtins.str]] () -> __main__.ClassA2[P1`1 = [builtins.int, builtins.str]]"
+reveal_type(ClassA3)  # N: Revealed type is "def [Ts1 = Unpack[Tuple[builtins.int, builtins.str]]] () -> __main__.ClassA3[Unpack[Ts1`1 = Unpack[Tuple[builtins.int, builtins.str]]]]"
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarDefaultsValid]
+from typing import TypeVar, ParamSpec, Any, List, Tuple
+from typing_extensions import TypeVarTuple, Unpack
+
+S0 = TypeVar("S0")
+S1 = TypeVar("S1", bound=int)
+
+P0 = ParamSpec("P0")
+Ts0 = TypeVarTuple("Ts0")
+
+T1 = TypeVar("T1", default=int)
+T2 = TypeVar("T2", bound=float, default=int)
+T3 = TypeVar("T3", bound=List[Any], default=List[int])
+T4 = TypeVar("T4", int, str, default=int)
+T5 = TypeVar("T5", default=S0)
+T6 = TypeVar("T6", bound=float, default=S1)
+# T7 = TypeVar("T7", bound=List[Any], default=List[S0])  # TODO
+
+P1 = ParamSpec("P1", default=[])
+P2 = ParamSpec("P2", default=...)
+P3 = ParamSpec("P3", default=[int, str])
+P4 = ParamSpec("P4", default=P0)
+
+Ts1 = TypeVarTuple("Ts1", default=Unpack[Tuple[int]])
+Ts2 = TypeVarTuple("Ts2", default=Unpack[Tuple[int, ...]])
+# Ts3 = TypeVarTuple("Ts3", default=Unpack[Ts0])  # TODO
+[builtins fixtures/tuple.pyi]
+
+[case testTypeVarDefaultsInvalid]
+from typing import TypeVar, ParamSpec, Tuple
+from typing_extensions import TypeVarTuple, Unpack
+
+T1 = TypeVar("T1", default=2)  # E: TypeVar "default" must be a type
+T2 = TypeVar("T2", default=[int, str])  # E: Bracketed expression "[...]" is not valid as a type \
+                                        # N: Did you mean "List[...]"? \
+                                        # E: TypeVar "default" must be a type
+
+P1 = ParamSpec("P1", default=int)  # E: The default argument to ParamSpec must be a list expression, ellipsis, or a ParamSpec
+P2 = ParamSpec("P2", default=2)  # E: The default argument to ParamSpec must be a list expression, ellipsis, or a ParamSpec
+P3 = ParamSpec("P3", default=(2, int))  # E: The default argument to ParamSpec must be a list expression, ellipsis, or a ParamSpec
+P4 = ParamSpec("P4", default=[2, int])  # E: Argument 0 of ParamSpec default must be a type
+
+Ts1 = TypeVarTuple("Ts1", default=2) # E: The default argument to TypeVarTuple must be an Unpacked tuple
+Ts2 = TypeVarTuple("Ts2", default=int)  # E: The default argument to TypeVarTuple must be an Unpacked tuple
+Ts3 = TypeVarTuple("Ts3", default=Tuple[int])  # E: The default argument to TypeVarTuple must be an Unpacked tuple
+[builtins fixtures/tuple.pyi]
diff --git a/test-data/unit/semanal-errors.test b/test-data/unit/semanal-errors.test
index d09ed87d3afcd..0c3de312cdfad 100644
--- a/test-data/unit/semanal-errors.test
+++ b/test-data/unit/semanal-errors.test
@@ -1465,8 +1465,9 @@ TVariadic2 = TypeVarTuple('TVariadic2')
 TP = TypeVarTuple('?')  # E: String argument 1 "?" to TypeVarTuple(...) does not match variable name "TP"
 TP2: int = TypeVarTuple('TP2')  # E: Cannot declare the type of a TypeVar or similar construct
 TP3 = TypeVarTuple()  # E: Too few arguments for TypeVarTuple()
-TP4 = TypeVarTuple('TP4', 'TP4')  # E: Only the first argument to TypeVarTuple has defined semantics
+TP4 = TypeVarTuple('TP4', 'TP4')  # E: Too many positional arguments for "TypeVarTuple"
 TP5 = TypeVarTuple(t='TP5')  # E: TypeVarTuple() expects a string literal as first argument
+TP6 = TypeVarTuple('TP6', bound=int)  # E: Unexpected keyword argument "bound" for "TypeVarTuple"
 
 x: TVariadic  # E: TypeVarTuple "TVariadic" is unbound
 y: Unpack[TVariadic]  # E: TypeVarTuple "TVariadic" is unbound

From fe0714acc7d890fe0331054065199097076f356e Mon Sep 17 00:00:00 2001
From: Ilya Priven <ilya.konstantinov@gmail.com>
Date: Wed, 7 Jun 2023 16:02:26 -0400
Subject: [PATCH 011/129] Make .test parser friendlier (#15385)

---
 mypy/test/data.py                             | 111 +++++++++---------
 mypy/test/meta/__init__.py                    |   0
 mypy/test/meta/test_parse_data.py             |  66 +++++++++++
 .../test_update_data.py}                      |   7 +-
 4 files changed, 126 insertions(+), 58 deletions(-)
 create mode 100644 mypy/test/meta/__init__.py
 create mode 100644 mypy/test/meta/test_parse_data.py
 rename mypy/test/{testupdatedata.py => meta/test_update_data.py} (94%)

diff --git a/mypy/test/data.py b/mypy/test/data.py
index daf815dbdbdcc..86193e303d9c3 100644
--- a/mypy/test/data.py
+++ b/mypy/test/data.py
@@ -12,7 +12,7 @@
 from abc import abstractmethod
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Iterator, NamedTuple, Pattern, Union
+from typing import Any, Iterator, NamedTuple, NoReturn, Pattern, Union
 from typing_extensions import Final, TypeAlias as _TypeAlias
 
 import pytest
@@ -77,11 +77,19 @@ def parse_test_case(case: DataDrivenTestCase) -> None:
     targets: dict[int, list[str]] = {}  # Fine-grained targets (per fine-grained update)
     test_modules: list[str] = []  # Modules which are deemed "test" (vs "fixture")
 
+    def _case_fail(msg: str) -> NoReturn:
+        pytest.fail(f"{case.file}:{case.line}: {msg}", pytrace=False)
+
     # Process the parsed items. Each item has a header of form [id args],
     # optionally followed by lines of text.
     item = first_item = test_items[0]
     test_modules.append("__main__")
     for item in test_items[1:]:
+
+        def _item_fail(msg: str) -> NoReturn:
+            item_abs_line = case.line + item.line - 2
+            pytest.fail(f"{case.file}:{item_abs_line}: {msg}", pytrace=False)
+
         if item.id in {"file", "fixture", "outfile", "outfile-re"}:
             # Record an extra file needed for the test case.
             assert item.arg is not None
@@ -132,9 +140,11 @@ def parse_test_case(case: DataDrivenTestCase) -> None:
             # File/directory to delete during a multi-step test case
             assert item.arg is not None
             m = re.match(r"(.*)\.([0-9]+)$", item.arg)
-            assert m, f"Invalid delete section: {item.arg}"
+            if m is None:
+                _item_fail(f"Invalid delete section {item.arg!r}")
             num = int(m.group(2))
-            assert num >= 2, f"Can't delete during step {num}"
+            if num < 2:
+                _item_fail(f"Can't delete during step {num}")
             full = join(base_path, m.group(1))
             deleted_paths.setdefault(num, set()).add(full)
         elif re.match(r"out[0-9]*$", item.id):
@@ -150,29 +160,18 @@ def parse_test_case(case: DataDrivenTestCase) -> None:
                 if arg.startswith("version"):
                     compare_op = arg[7:9]
                     if compare_op not in {">=", "=="}:
-                        raise ValueError(
-                            "{}, line {}: Only >= and == version checks are currently supported".format(
-                                case.file, item.line
-                            )
-                        )
+                        _item_fail("Only >= and == version checks are currently supported")
                     version_str = arg[9:]
                     try:
                         version = tuple(int(x) for x in version_str.split("."))
                     except ValueError:
-                        raise ValueError(
-                            '{}, line {}: "{}" is not a valid python version'.format(
-                                case.file, item.line, version_str
-                            )
-                        )
+                        _item_fail(f"{version_str!r} is not a valid python version")
                     if compare_op == ">=":
                         version_check = sys.version_info >= version
                     elif compare_op == "==":
                         if not 1 < len(version) < 4:
-                            raise ValueError(
-                                "{}, line {}: Only minor or patch version checks "
-                                'are currently supported with "==": "{}"'.format(
-                                    case.file, item.line, version_str
-                                )
+                            _item_fail(
+                                f'Only minor or patch version checks are currently supported with "==": {version_str!r}'
                             )
                         version_check = sys.version_info[: len(version)] == version
             if version_check:
@@ -189,10 +188,11 @@ def parse_test_case(case: DataDrivenTestCase) -> None:
         elif item.id == "triggered" and item.arg is None:
             triggered = item.data
         else:
-            raise ValueError(f"Invalid section header {item.id} in {case.file}:{item.line}")
+            section_str = item.id + (f" {item.arg}" if item.arg else "")
+            _item_fail(f"Invalid section header [{section_str}] in case {case.name!r}")
 
     if out_section_missing:
-        raise ValueError(f"{case.file}, line {first_item.line}: Required output section not found")
+        _case_fail(f"Required output section not found in case {case.name!r}")
 
     for passnum in stale_modules.keys():
         if passnum not in rechecked_modules:
@@ -204,11 +204,7 @@ def parse_test_case(case: DataDrivenTestCase) -> None:
             and passnum in rechecked_modules
             and not stale_modules[passnum].issubset(rechecked_modules[passnum])
         ):
-            raise ValueError(
-                (
-                    "Stale modules after pass {} must be a subset of rechecked modules ({}:{})"
-                ).format(passnum, case.file, first_item.line)
-            )
+            _case_fail(f"Stale modules after pass {passnum} must be a subset of rechecked modules")
 
     output_inline_start = len(output)
     input = first_item.data
@@ -219,10 +215,7 @@ def parse_test_case(case: DataDrivenTestCase) -> None:
     seen_files = set()
     for file, _ in files:
         if file in seen_files:
-            raise ValueError(
-                f"{case.file}, line {first_item.line}: Duplicated filename {file}. Did you include"
-                " it multiple times?"
-            )
+            _case_fail(f"Duplicated filename {file}. Did you include it multiple times?")
 
         seen_files.add(file)
 
@@ -367,12 +360,13 @@ def setup(self) -> None:
         self.steps = [steps.get(num, []) for num in range(2, max_step + 1)]
 
     def teardown(self) -> None:
-        assert self.old_cwd is not None and self.tmpdir is not None, "test was not properly set up"
-        os.chdir(self.old_cwd)
-        try:
-            self.tmpdir.cleanup()
-        except OSError:
-            pass
+        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
         self.old_cwd = None
         self.tmpdir = None
 
@@ -634,6 +628,16 @@ def pytest_pycollect_makeitem(collector: Any, name: str, obj: object) -> Any | N
     return None
 
 
+_case_name_pattern = re.compile(
+    r"(?P<name>[a-zA-Z_0-9]+)"
+    r"(?P<writescache>-writescache)?"
+    r"(?P<only_when>-only_when_cache|-only_when_nocache)?"
+    r"(-(?P<platform>posix|windows))?"
+    r"(?P<skip>-skip)?"
+    r"(?P<xfail>-xfail)?"
+)
+
+
 def split_test_cases(
     parent: DataFileCollector, suite: DataSuite, file: str
 ) -> Iterator[DataDrivenTestCase]:
@@ -644,40 +648,33 @@ def split_test_cases(
     """
     with open(file, encoding="utf-8") as f:
         data = f.read()
-    # number of groups in the below regex
-    NUM_GROUPS = 7
-    cases = re.split(
-        r"^\[case ([a-zA-Z_0-9]+)"
-        r"(-writescache)?"
-        r"(-only_when_cache|-only_when_nocache)?"
-        r"(-posix|-windows)?"
-        r"(-skip)?"
-        r"(-xfail)?"
-        r"\][ \t]*$\n",
-        data,
-        flags=re.DOTALL | re.MULTILINE,
-    )
-    line_no = cases[0].count("\n") + 1
+    cases = re.split(r"^\[case ([^]+)]+)\][ \t]*$\n", data, flags=re.DOTALL | re.MULTILINE)
+    cases_iter = iter(cases)
+    line_no = next(cases_iter).count("\n") + 1
     test_names = set()
-    for i in range(1, len(cases), NUM_GROUPS):
-        name, writescache, only_when, platform_flag, skip, xfail, data = cases[i : i + NUM_GROUPS]
+    for case_id in cases_iter:
+        data = next(cases_iter)
+
+        m = _case_name_pattern.fullmatch(case_id)
+        if not m:
+            raise RuntimeError(f"Invalid testcase id {case_id!r}")
+        name = m.group("name")
         if name in test_names:
             raise RuntimeError(
                 'Found a duplicate test name "{}" in {} on line {}'.format(
                     name, parent.name, line_no
                 )
             )
-        platform = platform_flag[1:] if platform_flag else None
         yield DataDrivenTestCase.from_parent(
             parent=parent,
             suite=suite,
             file=file,
             name=add_test_name_suffix(name, suite.test_name_suffix),
-            writescache=bool(writescache),
-            only_when=only_when,
-            platform=platform,
-            skip=bool(skip),
-            xfail=bool(xfail),
+            writescache=bool(m.group("writescache")),
+            only_when=m.group("only_when"),
+            platform=m.group("platform"),
+            skip=bool(m.group("skip")),
+            xfail=bool(m.group("xfail")),
             data=data,
             line=line_no,
         )
diff --git a/mypy/test/meta/__init__.py b/mypy/test/meta/__init__.py
new file mode 100644
index 0000000000000..e69de29bb2d1d
diff --git a/mypy/test/meta/test_parse_data.py b/mypy/test/meta/test_parse_data.py
new file mode 100644
index 0000000000000..6d9b32b96c7e6
--- /dev/null
+++ b/mypy/test/meta/test_parse_data.py
@@ -0,0 +1,66 @@
+"""
+A "meta test" which tests the parsing of .test files. This is not meant to become exhaustive
+but to ensure we maintain a basic level of ergonomics for mypy contributors.
+"""
+import subprocess
+import sys
+import textwrap
+from pathlib import Path
+
+from mypy.test.config import test_data_prefix
+from mypy.test.helpers import Suite
+
+
+class ParseTestDataSuite(Suite):
+    def _dedent(self, s: str) -> str:
+        return textwrap.dedent(s).lstrip()
+
+    def _run_pytest(self, data_suite: str) -> str:
+        p = Path(test_data_prefix) / "check-__fixture__.test"
+        assert not p.exists()
+        try:
+            p.write_text(data_suite)
+            test_nodeid = f"mypy/test/testcheck.py::TypeCheckSuite::{p.name}"
+            args = [sys.executable, "-m", "pytest", "-n", "0", "-s", test_nodeid]
+            proc = subprocess.run(args, capture_output=True, check=False)
+            return proc.stdout.decode()
+        finally:
+            p.unlink()
+
+    def test_parse_invalid_case(self) -> None:
+        # Arrange
+        data = self._dedent(
+            """
+            [case abc]
+            s: str
+            [case foo-XFAIL]
+            s: str
+            """
+        )
+
+        # Act
+        actual = self._run_pytest(data)
+
+        # Assert
+        assert "Invalid testcase id 'foo-XFAIL'" in actual
+
+    def test_parse_invalid_section(self) -> None:
+        # Arrange
+        data = self._dedent(
+            """
+            [case abc]
+            s: str
+            [unknownsection]
+            abc
+            """
+        )
+
+        # Act
+        actual = self._run_pytest(data)
+
+        # Assert
+        expected_lineno = data.splitlines().index("[unknownsection]") + 1
+        expected = (
+            f".test:{expected_lineno}: Invalid section header [unknownsection] in case 'abc'"
+        )
+        assert expected in actual
diff --git a/mypy/test/testupdatedata.py b/mypy/test/meta/test_update_data.py
similarity index 94%
rename from mypy/test/testupdatedata.py
rename to mypy/test/meta/test_update_data.py
index 54e9622a5e916..1239679072e61 100644
--- a/mypy/test/testupdatedata.py
+++ b/mypy/test/meta/test_update_data.py
@@ -1,3 +1,8 @@
+"""
+A "meta test" which tests the `--update-data` feature for updating .test files.
+Updating the expected output, especially when it's in the form of inline (comment) assertions,
+can be brittle, which is why we're "meta-testing" here.
+"""
 import shlex
 import subprocess
 import sys
@@ -16,7 +21,7 @@ def _run_pytest_update_data(self, data_suite: str, *, max_attempts: int) -> str:
         """
         p_test_data = Path(test_data_prefix)
         p_root = p_test_data.parent.parent
-        p = p_test_data / "check-update-data.test"
+        p = p_test_data / "check-__fixture__.test"
         assert not p.exists()
         try:
             p.write_text(textwrap.dedent(data_suite).lstrip())

From f54c3096b7d328dc59dd85af3a8ba28739dcfed0 Mon Sep 17 00:00:00 2001
From: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
Date: Wed, 7 Jun 2023 21:59:36 -0700
Subject: [PATCH 012/129] Fix crash when indexing TypedDict with empty key
 (#15392)

---
 mypy/messages.py                    |  3 ++-
 test-data/unit/check-typeddict.test | 12 ++++++++++++
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/mypy/messages.py b/mypy/messages.py
index a732d612123ca..cb95fb1c0bded 100644
--- a/mypy/messages.py
+++ b/mypy/messages.py
@@ -2989,8 +2989,9 @@ def _real_quick_ratio(a: str, b: str) -> float:
 
 
 def best_matches(current: str, options: Collection[str], n: int) -> list[str]:
+    if not current:
+        return []
     # narrow down options cheaply
-    assert current
     options = [o for o in options if _real_quick_ratio(current, o) > 0.75]
     if len(options) >= 50:
         options = [o for o in options if abs(len(o) - len(current)) <= 1]
diff --git a/test-data/unit/check-typeddict.test b/test-data/unit/check-typeddict.test
index 970dc05b488dd..fc487d2d553dd 100644
--- a/test-data/unit/check-typeddict.test
+++ b/test-data/unit/check-typeddict.test
@@ -2873,3 +2873,15 @@ foo({"foo": {"e": "foo"}})  # E: Type of TypedDict is ambiguous, none of ("A", "
                             # E: Argument 1 to "foo" has incompatible type "Dict[str, Dict[str, str]]"; expected "Union[A, B]"
 [builtins fixtures/dict.pyi]
 [typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictMissingEmptyKey]
+from typing_extensions import TypedDict
+
+class A(TypedDict):
+    my_attr_1: str
+    my_attr_2: int
+
+d: A
+d['']  # E: TypedDict "A" has no key ""
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]

From 8dde298fba2e021d1309a0d796a4a7efccc11e41 Mon Sep 17 00:00:00 2001
From: Ilya Priven <ilya.konstantinov@gmail.com>
Date: Thu, 8 Jun 2023 18:27:55 -0400
Subject: [PATCH 013/129] .git-blame-ignore-revs: exclude com2ann refactor
 (#15400)

---
 .git-blame-ignore-revs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
index 4256387e12092..006809c4a0e10 100644
--- a/.git-blame-ignore-revs
+++ b/.git-blame-ignore-revs
@@ -2,3 +2,5 @@
 97c5ee99bc98dc475512e549b252b23a6e7e0997
 # Use builtin generics and PEP 604 for type annotations wherever possible (#13427)
 23ee1e7aff357e656e3102435ad0fe3b5074571e
+# Use variable annotations (#10723)
+f98f78216ba9d6ab68c8e69c19e9f3c7926c5efe

From e253e7660d48422d3a0ea643bc1b11419fb3cddc Mon Sep 17 00:00:00 2001
From: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
Date: Thu, 8 Jun 2023 15:31:23 -0700
Subject: [PATCH 014/129] Fix stubtest crash in explicit init subclass (#15399)

---
 mypy/stubtest.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mypy/stubtest.py b/mypy/stubtest.py
index 4e038cfd75d14..a55be41d1a5d2 100644
--- a/mypy/stubtest.py
+++ b/mypy/stubtest.py
@@ -668,7 +668,7 @@ def _verify_arg_default_value(
 
 
 def maybe_strip_cls(name: str, args: list[nodes.Argument]) -> list[nodes.Argument]:
-    if name in ("__init_subclass__", "__class_getitem__"):
+    if args and name in ("__init_subclass__", "__class_getitem__"):
         # These are implicitly classmethods. If the stub chooses not to have @classmethod, we
         # should remove the cls argument
         if args[0].variable.name == "cls":

From 27593bc23cf6be4ad9a37d6c1bc13abc5f2190ec Mon Sep 17 00:00:00 2001
From: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
Date: Thu, 8 Jun 2023 15:31:41 -0700
Subject: [PATCH 015/129] Improve stubtest error message (#15398)

---
 mypy/stubtest.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/mypy/stubtest.py b/mypy/stubtest.py
index a55be41d1a5d2..f06faa962b07f 100644
--- a/mypy/stubtest.py
+++ b/mypy/stubtest.py
@@ -209,7 +209,12 @@ def test_module(module_name: str) -> Iterator[Error]:
     except KeyboardInterrupt:
         raise
     except BaseException as e:
-        yield Error([module_name], f"failed to import, {type(e).__name__}: {e}", stub, MISSING)
+        note = ""
+        if isinstance(e, ModuleNotFoundError):
+            note = " Maybe install the runtime package or alter PYTHONPATH?"
+        yield Error(
+            [module_name], f"failed to import.{note} {type(e).__name__}: {e}", stub, MISSING
+        )
         return
 
     with warnings.catch_warnings():

From 4baf672a8fe19bb78bcb99ec706e3aa0f7c8605c Mon Sep 17 00:00:00 2001
From: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
Date: Thu, 8 Jun 2023 16:53:45 -0700
Subject: [PATCH 016/129] Fix abstract and non-abstract variant error for
 prop.deleter (#15395)

---
 mypy/semanal.py                    |  2 ++
 test-data/unit/check-abstract.test | 41 ++++++++++++++++++++++++++++--
 2 files changed, 41 insertions(+), 2 deletions(-)

diff --git a/mypy/semanal.py b/mypy/semanal.py
index c5a6989f4f61b..c95e1c8741dd2 100644
--- a/mypy/semanal.py
+++ b/mypy/semanal.py
@@ -1337,6 +1337,8 @@ def analyze_property_with_multi_part_definition(self, defn: OverloadedFuncDef) -
                             first_item.var.is_settable_property = True
                             # Get abstractness from the original definition.
                             item.func.abstract_status = first_item.func.abstract_status
+                        if node.name == "deleter":
+                            item.func.abstract_status = first_item.func.abstract_status
                     else:
                         self.fail(
                             f"Only supported top decorator is @{first_item.func.name}.setter", item
diff --git a/test-data/unit/check-abstract.test b/test-data/unit/check-abstract.test
index 8a13e5cb57608..3a0a30a14462f 100644
--- a/test-data/unit/check-abstract.test
+++ b/test-data/unit/check-abstract.test
@@ -735,7 +735,44 @@ class A(metaclass=ABCMeta):
     def x(self) -> int: pass
     @x.setter
     def x(self, x: int) -> None: pass
-[out]
+
+[case testReadWriteDeleteAbstractProperty]
+from abc import ABC, abstractmethod
+class Abstract(ABC):
+    @property
+    @abstractmethod
+    def prop(self) -> str: ...
+
+    @prop.setter
+    @abstractmethod
+    def prop(self, code: str) -> None: ...
+
+    @prop.deleter
+    @abstractmethod
+    def prop(self) -> None: ...
+
+class Good(Abstract):
+    @property
+    def prop(self) -> str: ...
+    @prop.setter
+    def prop(self, code: str) -> None: ...
+    @prop.deleter
+    def prop(self) -> None: ...
+
+class Bad1(Abstract):
+    @property  # E: Read-only property cannot override read-write property
+    def prop(self) -> str: ...
+
+class ThisShouldProbablyError(Abstract):
+    @property
+    def prop(self) -> str: ...
+    @prop.setter
+    def prop(self, code: str) -> None: ...
+
+a = Good()
+reveal_type(a.prop)  # N: Revealed type is "builtins.str"
+a.prop = 123  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
+[builtins fixtures/property.pyi]
 
 [case testInstantiateClassWithReadOnlyAbstractProperty]
 from abc import abstractproperty, ABCMeta
@@ -767,7 +804,7 @@ b = B()
 b.x() # E: "int" not callable
 [builtins fixtures/property.pyi]
 
-[case testImplementReradWriteAbstractPropertyViaProperty]
+[case testImplementReadWriteAbstractPropertyViaProperty]
 from abc import abstractproperty, ABCMeta
 class A(metaclass=ABCMeta):
     @abstractproperty

From 3e982a0bd3b7d4e25edc4046af07e2c2c1011784 Mon Sep 17 00:00:00 2001
From: Ivan Levkivskyi <levkivskyi@gmail.com>
Date: Fri, 9 Jun 2023 16:27:34 +0100
Subject: [PATCH 017/129] Fix crash on joins with recursive tuples (#15402)

Fixes #15351

This may have some perf impact, but I predict it will be minimal (and I
didn't notice anything locally).
---
 mypy/typeops.py                           | 6 ++++++
 test-data/unit/check-recursive-types.test | 9 +++++++++
 2 files changed, 15 insertions(+)

diff --git a/mypy/typeops.py b/mypy/typeops.py
index ee544c6740bbd..58a641a54ab70 100644
--- a/mypy/typeops.py
+++ b/mypy/typeops.py
@@ -76,12 +76,18 @@ def is_recursive_pair(s: Type, t: Type) -> bool:
             isinstance(get_proper_type(t), (Instance, UnionType))
             or isinstance(t, TypeAliasType)
             and t.is_recursive
+            # Tuple types are special, they can cause an infinite recursion even if
+            # the other type is not recursive, because of the tuple fallback that is
+            # calculated "on the fly".
+            or isinstance(get_proper_type(s), TupleType)
         )
     if isinstance(t, TypeAliasType) and t.is_recursive:
         return (
             isinstance(get_proper_type(s), (Instance, UnionType))
             or isinstance(s, TypeAliasType)
             and s.is_recursive
+            # Same as above.
+            or isinstance(get_proper_type(t), TupleType)
         )
     return False
 
diff --git a/test-data/unit/check-recursive-types.test b/test-data/unit/check-recursive-types.test
index 75f2433c6d8c0..51f07cdccf8fa 100644
--- a/test-data/unit/check-recursive-types.test
+++ b/test-data/unit/check-recursive-types.test
@@ -937,3 +937,12 @@ x: A[int, str]
 if last is not None:
     reveal_type(last)  # N: Revealed type is "Tuple[builtins.int, builtins.str, Union[Tuple[builtins.int, builtins.str, Union[..., None]], None]]"
 [builtins fixtures/tuple.pyi]
+
+[case testRecursiveAliasLiteral]
+from typing import Tuple
+from typing_extensions import Literal
+
+NotFilter = Tuple[Literal["not"], "NotFilter"]
+n: NotFilter
+reveal_type(n[1][1][0])  # N: Revealed type is "Literal['not']"
+[builtins fixtures/tuple.pyi]

From 2c66cba59fefadd0f3ab71a605d9a458fb14f1f6 Mon Sep 17 00:00:00 2001
From: Ivan Levkivskyi <levkivskyi@gmail.com>
Date: Fri, 9 Jun 2023 16:28:20 +0100
Subject: [PATCH 018/129] Correctly track loop depth for nested
 functions/classes (#15403)

Fixes #15378
---
 mypy/semanal.py                      | 22 +++++++++++++---------
 test-data/unit/check-statements.test | 14 ++++++++++++++
 2 files changed, 27 insertions(+), 9 deletions(-)

diff --git a/mypy/semanal.py b/mypy/semanal.py
index c95e1c8741dd2..923cb789b454e 100644
--- a/mypy/semanal.py
+++ b/mypy/semanal.py
@@ -375,7 +375,7 @@ class SemanticAnalyzer(
     missing_names: list[set[str]]
     # Callbacks that will be called after semantic analysis to tweak things.
     patches: list[tuple[int, Callable[[], None]]]
-    loop_depth = 0  # Depth of breakable loops
+    loop_depth: list[int]  # Depth of breakable loops
     cur_mod_id = ""  # Current module id (or None) (phase 2)
     _is_stub_file = False  # Are we analyzing a stub file?
     _is_typeshed_stub_file = False  # Are we analyzing a typeshed stub file?
@@ -428,7 +428,7 @@ def __init__(
         self.tvar_scope = TypeVarLikeScope()
         self.function_stack = []
         self.block_depth = [0]
-        self.loop_depth = 0
+        self.loop_depth = [0]
         self.errors = errors
         self.modules = modules
         self.msg = MessageBuilder(errors, modules)
@@ -1810,12 +1810,14 @@ def enter_class(self, info: TypeInfo) -> None:
         self.locals.append(None)  # Add class scope
         self.is_comprehension_stack.append(False)
         self.block_depth.append(-1)  # The class body increments this to 0
+        self.loop_depth.append(0)
         self._type = info
         self.missing_names.append(set())
 
     def leave_class(self) -> None:
         """Restore analyzer state."""
         self.block_depth.pop()
+        self.loop_depth.pop()
         self.locals.pop()
         self.is_comprehension_stack.pop()
         self._type = self.type_stack.pop()
@@ -3221,7 +3223,7 @@ def unwrap_final(self, s: AssignmentStmt) -> bool:
         if lval.is_new_def:
             lval.is_inferred_def = s.type is None
 
-        if self.loop_depth > 0:
+        if self.loop_depth[-1] > 0:
             self.fail("Cannot use Final inside a loop", s)
         if self.type and self.type.is_protocol:
             self.msg.protocol_members_cant_be_final(s)
@@ -4700,9 +4702,9 @@ def visit_operator_assignment_stmt(self, s: OperatorAssignmentStmt) -> None:
     def visit_while_stmt(self, s: WhileStmt) -> None:
         self.statement = s
         s.expr.accept(self)
-        self.loop_depth += 1
+        self.loop_depth[-1] += 1
         s.body.accept(self)
-        self.loop_depth -= 1
+        self.loop_depth[-1] -= 1
         self.visit_block_maybe(s.else_body)
 
     def visit_for_stmt(self, s: ForStmt) -> None:
@@ -4724,20 +4726,20 @@ def visit_for_stmt(self, s: ForStmt) -> None:
                 self.store_declared_types(s.index, analyzed)
                 s.index_type = analyzed
 
-        self.loop_depth += 1
+        self.loop_depth[-1] += 1
         self.visit_block(s.body)
-        self.loop_depth -= 1
+        self.loop_depth[-1] -= 1
 
         self.visit_block_maybe(s.else_body)
 
     def visit_break_stmt(self, s: BreakStmt) -> None:
         self.statement = s
-        if self.loop_depth == 0:
+        if self.loop_depth[-1] == 0:
             self.fail('"break" outside loop', s, serious=True, blocker=True)
 
     def visit_continue_stmt(self, s: ContinueStmt) -> None:
         self.statement = s
-        if self.loop_depth == 0:
+        if self.loop_depth[-1] == 0:
             self.fail('"continue" outside loop', s, serious=True, blocker=True)
 
     def visit_if_stmt(self, s: IfStmt) -> None:
@@ -6232,6 +6234,7 @@ def enter(
         self.nonlocal_decls.append(set())
         # -1 since entering block will increment this to 0.
         self.block_depth.append(-1)
+        self.loop_depth.append(0)
         self.missing_names.append(set())
         try:
             yield
@@ -6241,6 +6244,7 @@ def enter(
             self.global_decls.pop()
             self.nonlocal_decls.pop()
             self.block_depth.pop()
+            self.loop_depth.pop()
             self.missing_names.pop()
 
     def is_func_scope(self) -> bool:
diff --git a/test-data/unit/check-statements.test b/test-data/unit/check-statements.test
index 3cb8864f9207c..29e2c5ba3266a 100644
--- a/test-data/unit/check-statements.test
+++ b/test-data/unit/check-statements.test
@@ -2212,3 +2212,17 @@ main:1: error: Module "typing" has no attribute "_FutureFeatureFixture"
 main:1: note: Use `from typing_extensions import _FutureFeatureFixture` instead
 main:1: note: See https://mypy.readthedocs.io/en/stable/runtime_troubles.html#using-new-additions-to-the-typing-module
 [builtins fixtures/tuple.pyi]
+
+[case testNoCrashOnBreakOutsideLoopFunction]
+def foo():
+    for x in [1, 2]:
+        def inner():
+            break  # E: "break" outside loop
+[builtins fixtures/list.pyi]
+
+[case testNoCrashOnBreakOutsideLoopClass]
+class Outer:
+    for x in [1, 2]:
+        class Inner:
+            break  # E: "break" outside loop
+[builtins fixtures/list.pyi]

From 3cedd2725c9e8f6ec3dac5e72bf65bddbfccce4c Mon Sep 17 00:00:00 2001
From: Ivan Levkivskyi <levkivskyi@gmail.com>
Date: Fri, 9 Jun 2023 18:55:44 +0100
Subject: [PATCH 019/129] Fix crash on NamedTuple as attribute (#15404)

Fixes #15380

Note I also update the `NamedTuple` fixture to be much closer to real
definition in `typing.pyi` in typeshed.
---
 mypy/semanal.py                               |  9 ++++++---
 test-data/unit/check-namedtuple.test          | 14 ++++++++++++--
 test-data/unit/fixtures/typing-namedtuple.pyi | 11 ++++++++---
 3 files changed, 26 insertions(+), 8 deletions(-)

diff --git a/mypy/semanal.py b/mypy/semanal.py
index 923cb789b454e..073bde6616174 100644
--- a/mypy/semanal.py
+++ b/mypy/semanal.py
@@ -3069,6 +3069,12 @@ def analyze_namedtuple_assign(self, s: AssignmentStmt) -> bool:
         if len(s.lvalues) != 1 or not isinstance(s.lvalues[0], (NameExpr, MemberExpr)):
             return False
         lvalue = s.lvalues[0]
+        if isinstance(lvalue, MemberExpr):
+            if isinstance(s.rvalue, CallExpr) and isinstance(s.rvalue.callee, RefExpr):
+                fullname = s.rvalue.callee.fullname
+                if fullname == "collections.namedtuple" or fullname in TYPED_NAMEDTUPLE_NAMES:
+                    self.fail("NamedTuple type as an attribute is not supported", lvalue)
+            return False
         name = lvalue.name
         namespace = self.qualified_name(name)
         with self.tvar_scope_frame(self.tvar_scope.class_frame(namespace)):
@@ -3077,9 +3083,6 @@ def analyze_namedtuple_assign(self, s: AssignmentStmt) -> bool:
             )
             if internal_name is None:
                 return False
-            if isinstance(lvalue, MemberExpr):
-                self.fail("NamedTuple type as an attribute is not supported", lvalue)
-                return False
             if internal_name != name:
                 self.fail(
                     'First argument to namedtuple() should be "{}", not "{}"'.format(
diff --git a/test-data/unit/check-namedtuple.test b/test-data/unit/check-namedtuple.test
index 6b9f139f541cc..5eed70246e8c9 100644
--- a/test-data/unit/check-namedtuple.test
+++ b/test-data/unit/check-namedtuple.test
@@ -938,8 +938,9 @@ class A:
     def __init__(self) -> None:
         self.b = NamedTuple('x', [('s', str), ('n', int)])  # E: NamedTuple type as an attribute is not supported
 
-reveal_type(A().b)  # N: Revealed type is "Any"
+reveal_type(A().b)  # N: Revealed type is "typing.NamedTuple"
 [builtins fixtures/tuple.pyi]
+[typing fixtures/typing-namedtuple.pyi]
 
 [case testNamedTupleWrongfile]
 from typing import NamedTuple
@@ -983,7 +984,7 @@ class Both2(Other, Bar): ...
 class Both3(Biz, Other): ...
 
 def print_namedtuple(obj: NamedTuple) -> None:
-    reveal_type(obj.name)  # N: Revealed type is "builtins.str"
+    reveal_type(obj._fields)  # N: Revealed type is "builtins.tuple[builtins.str, ...]"
 
 b1: Bar
 b2: Baz
@@ -1337,3 +1338,12 @@ class SNT(NT[int]): ...
 reveal_type(SNT("test", 42).meth())  # N: Revealed type is "Tuple[builtins.str, builtins.int, fallback=__main__.SNT]"
 [builtins fixtures/tuple.pyi]
 [typing fixtures/typing-namedtuple.pyi]
+
+[case testNoCrashUnsupportedNamedTuple]
+from typing import NamedTuple
+class Test:
+    def __init__(self, field) -> None:
+        self.Item = NamedTuple("x", [(field, str)])  # E: NamedTuple type as an attribute is not supported
+        self.item: self.Item  # E: Name "self.Item" is not defined
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-namedtuple.pyi]
diff --git a/test-data/unit/fixtures/typing-namedtuple.pyi b/test-data/unit/fixtures/typing-namedtuple.pyi
index c8658a815a13d..f4744575fc092 100644
--- a/test-data/unit/fixtures/typing-namedtuple.pyi
+++ b/test-data/unit/fixtures/typing-namedtuple.pyi
@@ -6,6 +6,8 @@ Type = 0
 Literal = 0
 Optional = 0
 Self = 0
+Tuple = 0
+ClassVar = 0
 
 T = TypeVar('T')
 T_co = TypeVar('T_co', covariant=True)
@@ -18,6 +20,9 @@ class Mapping(Iterable[KT], Generic[KT, T_co]):
     def keys(self) -> Iterable[T]: pass  # Approximate return type
     def __getitem__(self, key: T) -> T_co: pass
 
-class Tuple(Sequence): pass
-class NamedTuple(Tuple):
-    name: str
+class NamedTuple(tuple[Any, ...]):
+    _fields: ClassVar[tuple[str, ...]]
+    @overload
+    def __init__(self, typename: str, fields: Iterable[tuple[str, Any]] = ...) -> None: ...
+    @overload
+    def __init__(self, typename: str, fields: None = None, **kwargs: Any) -> None: ...

From e7b917ec7532206b996542570f4b68a33c3ff771 Mon Sep 17 00:00:00 2001
From: Ivan Levkivskyi <levkivskyi@gmail.com>
Date: Sat, 10 Jun 2023 00:48:01 +0100
Subject: [PATCH 020/129] Fix crash on follow_imports_for_stubs (#15407)

---
 mypy/build.py                   |  9 +++++----
 mypy/messages.py                |  2 +-
 test-data/unit/check-flags.test | 10 ++++++++++
 test-data/unit/cmdline.test     |  8 ++++++++
 4 files changed, 24 insertions(+), 5 deletions(-)

diff --git a/mypy/build.py b/mypy/build.py
index c239afb562368..7913eae9c6ed8 100644
--- a/mypy/build.py
+++ b/mypy/build.py
@@ -116,7 +116,10 @@
     "types",
     "typing_extensions",
     "mypy_extensions",
-    "_importlib_modulespec",
+    "_typeshed",
+    "_collections_abc",
+    "collections",
+    "collections.abc",
     "sys",
     "abc",
 }
@@ -659,8 +662,6 @@ def __init__(
         for module in CORE_BUILTIN_MODULES:
             if options.use_builtins_fixtures:
                 continue
-            if module == "_importlib_modulespec":
-                continue
             path = self.find_module_cache.find_module(module)
             if not isinstance(path, str):
                 raise CompileError(
@@ -2637,7 +2638,7 @@ def find_module_and_diagnose(
                 result.endswith(".pyi")  # Stubs are always normal
                 and not options.follow_imports_for_stubs  # except when they aren't
             )
-            or id in mypy.semanal_main.core_modules  # core is always normal
+            or id in CORE_BUILTIN_MODULES  # core is always normal
         ):
             follow_imports = "normal"
         if skip_diagnose:
diff --git a/mypy/messages.py b/mypy/messages.py
index cb95fb1c0bded..9d703a1a974af 100644
--- a/mypy/messages.py
+++ b/mypy/messages.py
@@ -2437,7 +2437,7 @@ def format_literal_value(typ: LiteralType) -> str:
     if isinstance(typ, Instance):
         itype = typ
         # Get the short name of the type.
-        if itype.type.fullname in ("types.ModuleType", "_importlib_modulespec.ModuleType"):
+        if itype.type.fullname == "types.ModuleType":
             # Make some common error messages simpler and tidier.
             base_str = "Module"
             if itype.extra_attrs and itype.extra_attrs.mod_name and module_names:
diff --git a/test-data/unit/check-flags.test b/test-data/unit/check-flags.test
index 39fcef1db6738..4a43224260d11 100644
--- a/test-data/unit/check-flags.test
+++ b/test-data/unit/check-flags.test
@@ -2174,3 +2174,13 @@ def f(x: bytes, y: bytearray, z: memoryview) -> None:
     x in y
     x in z
 [builtins fixtures/primitives.pyi]
+
+[case testNoCrashFollowImportsForStubs]
+# flags: --config-file tmp/mypy.ini
+{**{"x": "y"}}
+
+[file mypy.ini]
+\[mypy]
+follow_imports = skip
+follow_imports_for_stubs = true
+[builtins fixtures/dict.pyi]
diff --git a/test-data/unit/cmdline.test b/test-data/unit/cmdline.test
index c2e98cdb74f91..b87bb7f17eb0f 100644
--- a/test-data/unit/cmdline.test
+++ b/test-data/unit/cmdline.test
@@ -1484,6 +1484,10 @@ note: A user-defined top-level module with name "typing" is not supported
 [file dir/stdlib/types.pyi]
 [file dir/stdlib/typing.pyi]
 [file dir/stdlib/typing_extensions.pyi]
+[file dir/stdlib/_typeshed.pyi]
+[file dir/stdlib/_collections_abc.pyi]
+[file dir/stdlib/collections/abc.pyi]
+[file dir/stdlib/collections/__init__.pyi]
 [file dir/stdlib/VERSIONS]
 [out]
 Failed to find builtin module mypy_extensions, perhaps typeshed is broken?
@@ -1523,6 +1527,10 @@ class dict: pass
 [file dir/stdlib/typing.pyi]
 [file dir/stdlib/mypy_extensions.pyi]
 [file dir/stdlib/typing_extensions.pyi]
+[file dir/stdlib/_typeshed.pyi]
+[file dir/stdlib/_collections_abc.pyi]
+[file dir/stdlib/collections/abc.pyi]
+[file dir/stdlib/collections/__init__.pyi]
 [file dir/stdlib/foo.pyi]
 1()  # Errors are reported if the file was explicitly passed on the command line
 [file dir/stdlib/VERSIONS]

From a108c670c395c719e81cd87674654daf54ec95ee Mon Sep 17 00:00:00 2001
From: Ilya Priven <ilya.konstantinov@gmail.com>
Date: Sun, 11 Jun 2023 09:41:25 -0400
Subject: [PATCH 021/129] Add get_expression_type to CheckerPluginInterface
 (#15369)

Fixes #14845.

p.s. In the issue above, I was concerned that adding this method would
create an avenue for infinite recursions (if called carelessly), but in
fact I haven't managed to induce it, e.g. FunctionSigContext has `args`
but not the call expression itself.
---
 mypy/checker.py                             |  3 +++
 mypy/plugin.py                              |  5 +++++
 mypy/plugins/attrs.py                       | 19 ++++---------------
 test-data/unit/check-custom-plugin.test     |  5 ++++-
 test-data/unit/plugins/function_sig_hook.py | 21 +++++++++------------
 5 files changed, 25 insertions(+), 28 deletions(-)

diff --git a/mypy/checker.py b/mypy/checker.py
index c1c31538b7de9..87bd9915af973 100644
--- a/mypy/checker.py
+++ b/mypy/checker.py
@@ -6793,6 +6793,9 @@ def has_valid_attribute(self, typ: Type, name: str) -> bool:
             )
         return not watcher.has_new_errors()
 
+    def get_expression_type(self, node: Expression, type_context: Type | None = None) -> Type:
+        return self.expr_checker.accept(node, type_context=type_context)
+
 
 class CollectArgTypeVarTypes(TypeTraverserVisitor):
     """Collects the non-nested argument types in a set."""
diff --git a/mypy/plugin.py b/mypy/plugin.py
index cf124b45d04fd..4d62c2bd184b8 100644
--- a/mypy/plugin.py
+++ b/mypy/plugin.py
@@ -250,6 +250,11 @@ def named_generic_type(self, name: str, args: list[Type]) -> Instance:
         """Construct an instance of a builtin type with given type arguments."""
         raise NotImplementedError
 
+    @abstractmethod
+    def get_expression_type(self, node: Expression, type_context: Type | None = None) -> Type:
+        """Checks the type of the given expression."""
+        raise NotImplementedError
+
 
 @trait
 class SemanticAnalyzerPluginInterface:
diff --git a/mypy/plugins/attrs.py b/mypy/plugins/attrs.py
index afd9423d68208..e05a8e44b2f83 100644
--- a/mypy/plugins/attrs.py
+++ b/mypy/plugins/attrs.py
@@ -9,7 +9,6 @@
 
 import mypy.plugin  # To avoid circular imports.
 from mypy.applytype import apply_generic_arguments
-from mypy.checker import TypeChecker
 from mypy.errorcodes import LITERAL_REQ
 from mypy.expandtype import expand_type, expand_type_by_instance
 from mypy.exprtotype import TypeTranslationError, expr_to_unanalyzed_type
@@ -1048,13 +1047,7 @@ def evolve_function_sig_callback(ctx: mypy.plugin.FunctionSigContext) -> Callabl
         return ctx.default_signature  # leave it to the type checker to complain
 
     inst_arg = ctx.args[0][0]
-
-    # <hack>
-    assert isinstance(ctx.api, TypeChecker)
-    inst_type = ctx.api.expr_checker.accept(inst_arg)
-    # </hack>
-
-    inst_type = get_proper_type(inst_type)
+    inst_type = get_proper_type(ctx.api.get_expression_type(inst_arg))
     inst_type_str = format_type_bare(inst_type, ctx.api.options)
 
     attr_types = _get_expanded_attr_types(ctx, inst_type, inst_type, inst_type)
@@ -1074,14 +1067,10 @@ def evolve_function_sig_callback(ctx: mypy.plugin.FunctionSigContext) -> Callabl
 
 def fields_function_sig_callback(ctx: mypy.plugin.FunctionSigContext) -> CallableType:
     """Provide the signature for `attrs.fields`."""
-    if not ctx.args or len(ctx.args) != 1 or not ctx.args[0] or not ctx.args[0][0]:
+    if len(ctx.args) != 1 or len(ctx.args[0]) != 1:
         return ctx.default_signature
 
-    # <hack>
-    assert isinstance(ctx.api, TypeChecker)
-    inst_type = ctx.api.expr_checker.accept(ctx.args[0][0])
-    # </hack>
-    proper_type = get_proper_type(inst_type)
+    proper_type = get_proper_type(ctx.api.get_expression_type(ctx.args[0][0]))
 
     # fields(Any) -> Any, fields(type[Any]) -> Any
     if (
@@ -1098,7 +1087,7 @@ def fields_function_sig_callback(ctx: mypy.plugin.FunctionSigContext) -> Callabl
         inner = get_proper_type(proper_type.upper_bound)
         if isinstance(inner, Instance):
             # We need to work arg_types to compensate for the attrs stubs.
-            arg_types = [inst_type]
+            arg_types = [proper_type]
             cls = inner.type
     elif isinstance(proper_type, CallableType):
         cls = proper_type.type_object()
diff --git a/test-data/unit/check-custom-plugin.test b/test-data/unit/check-custom-plugin.test
index c81de675d8082..ec5bce219dbd7 100644
--- a/test-data/unit/check-custom-plugin.test
+++ b/test-data/unit/check-custom-plugin.test
@@ -887,7 +887,10 @@ plugins=<ROOT>/test-data/unit/plugins/descriptor.py
 # flags: --config-file tmp/mypy.ini
 
 def dynamic_signature(arg1: str) -> str: ...
-reveal_type(dynamic_signature(1))  # N: Revealed type is "builtins.int"
+a: int = 1
+reveal_type(dynamic_signature(a))  # N: Revealed type is "builtins.int"
+b: bytes = b'foo'
+reveal_type(dynamic_signature(b))  # N: Revealed type is "builtins.bytes"
 [file mypy.ini]
 \[mypy]
 plugins=<ROOT>/test-data/unit/plugins/function_sig_hook.py
diff --git a/test-data/unit/plugins/function_sig_hook.py b/test-data/unit/plugins/function_sig_hook.py
index d83c7df262092..4d901b96716e7 100644
--- a/test-data/unit/plugins/function_sig_hook.py
+++ b/test-data/unit/plugins/function_sig_hook.py
@@ -1,5 +1,5 @@
-from mypy.plugin import CallableType, CheckerPluginInterface, FunctionSigContext, Plugin
-from mypy.types import Instance, Type
+from mypy.plugin import CallableType, FunctionSigContext, Plugin
+
 
 class FunctionSigPlugin(Plugin):
     def get_function_signature_hook(self, fullname):
@@ -7,20 +7,17 @@ def get_function_signature_hook(self, fullname):
             return my_hook
         return None
 
-def _str_to_int(api: CheckerPluginInterface, typ: Type) -> Type:
-    if isinstance(typ, Instance):
-        if typ.type.fullname == 'builtins.str':
-            return api.named_generic_type('builtins.int', [])
-        elif typ.args:
-            return typ.copy_modified(args=[_str_to_int(api, t) for t in typ.args])
-
-    return typ
 
 def my_hook(ctx: FunctionSigContext) -> CallableType:
+    arg1_args = ctx.args[0]
+    if len(arg1_args) != 1:
+        return ctx.default_signature
+    arg1_type = ctx.api.get_expression_type(arg1_args[0])
     return ctx.default_signature.copy_modified(
-        arg_types=[_str_to_int(ctx.api, t) for t in ctx.default_signature.arg_types],
-        ret_type=_str_to_int(ctx.api, ctx.default_signature.ret_type),
+        arg_types=[arg1_type],
+        ret_type=arg1_type,
     )
 
+
 def plugin(version):
     return FunctionSigPlugin

From 9e7bc383eb9a5df94e8bf6117f008d97017a1fcf Mon Sep 17 00:00:00 2001
From: Ivan Levkivskyi <levkivskyi@gmail.com>
Date: Sun, 11 Jun 2023 21:08:12 +0100
Subject: [PATCH 022/129] Always allow returning Any from lambda (#15413)

---
 mypy/checker.py                 |  1 +
 test-data/unit/check-flags.test | 11 +++++++++++
 2 files changed, 12 insertions(+)

diff --git a/mypy/checker.py b/mypy/checker.py
index 87bd9915af973..1026376cce630 100644
--- a/mypy/checker.py
+++ b/mypy/checker.py
@@ -4270,6 +4270,7 @@ def check_return_stmt(self, s: ReturnStmt) -> None:
                             isinstance(return_type, Instance)
                             and return_type.type.fullname == "builtins.object"
                         )
+                        and not is_lambda
                     ):
                         self.msg.incorrectly_returning_any(return_type, s)
                     return
diff --git a/test-data/unit/check-flags.test b/test-data/unit/check-flags.test
index 4a43224260d11..6ec0849146c04 100644
--- a/test-data/unit/check-flags.test
+++ b/test-data/unit/check-flags.test
@@ -2184,3 +2184,14 @@ def f(x: bytes, y: bytearray, z: memoryview) -> None:
 follow_imports = skip
 follow_imports_for_stubs = true
 [builtins fixtures/dict.pyi]
+
+[case testReturnAnyLambda]
+# flags: --warn-return-any
+from typing import Any, Callable
+
+def cb(f: Callable[[int], int]) -> None: ...
+a: Any
+cb(lambda x: a)  # OK
+
+fn = lambda x: a
+cb(fn)

From 4aa18ea818bfe55617c3f2423d1020796ceccdfc Mon Sep 17 00:00:00 2001
From: jhance <jhance@users.noreply.github.com>
Date: Mon, 12 Jun 2023 03:50:31 -0700
Subject: [PATCH 023/129] Increment version for 1.5-dev (#15405)

---
 mypy/version.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mypy/version.py b/mypy/version.py
index 826ba00201003..42cda2fc7794e 100644
--- a/mypy/version.py
+++ b/mypy/version.py
@@ -8,7 +8,7 @@
 # - Release versions have the form "1.2.3".
 # - Dev versions have the form "1.2.3+dev" (PLUS sign to conform to PEP 440).
 # - Before 1.0 we had the form "0.NNN".
-__version__ = "1.4.0+dev"
+__version__ = "1.5.0+dev"
 base_version = __version__
 
 mypy_dir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))

From 9b9272ae758e23653c81c94031ec03892d31622a Mon Sep 17 00:00:00 2001
From: Logan Hunt <39638017+dosisod@users.noreply.github.com>
Date: Mon, 12 Jun 2023 03:57:23 -0700
Subject: [PATCH 024/129] [mypyc] Don't explicitly assign `NULL` values in
 setup functions (#15379)

While investigating something unrelated I stumbled across the `*_setup`
functions, and I noticed that they contain a lot of code that looks like
this:

```c
self->abc = NULL;
self->xyz = NULL;
// ...
```

Something told me that assigning `NULL` to a bunch of fields is propably
not needed, and when looking at the docs for `tp_alloc()` I found this
reference to
[`allocfunc`](https://docs.python.org/3/c-api/typeobj.html#c.allocfunc),
the typedef for `tp_alloc()`:

> It should return a pointer to a block of memory of adequate length for
the instance, suitably aligned, ***and initialized to zeros***, ...

Emphasis is mine.

Basically I added a simple check that removes lines that assigns `NULL`
values in setup functions. This removes about ~4100 lines from the C
file when self-compiling.
---
 mypyc/codegen/emitclass.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/mypyc/codegen/emitclass.py b/mypyc/codegen/emitclass.py
index 6a272d1aee2bc..eac7a2207972d 100644
--- a/mypyc/codegen/emitclass.py
+++ b/mypyc/codegen/emitclass.py
@@ -578,7 +578,12 @@ def generate_setup_for_class(
 
     for base in reversed(cl.base_mro):
         for attr, rtype in base.attributes.items():
-            emitter.emit_line(rf"self->{emitter.attr(attr)} = {emitter.c_undefined_value(rtype)};")
+            value = emitter.c_undefined_value(rtype)
+
+            # We don't need to set this field to NULL since tp_alloc() already
+            # zero-initializes `self`.
+            if value != "NULL":
+                emitter.emit_line(rf"self->{emitter.attr(attr)} = {value};")
 
     # Initialize attributes to default values, if necessary
     if defaults_fn is not None:

From cab8c674ebef944498ae4e9a89cd9c77316656ec Mon Sep 17 00:00:00 2001
From: Ilya Priven <ilya.konstantinov@gmail.com>
Date: Mon, 12 Jun 2023 13:05:11 -0400
Subject: [PATCH 025/129] test_parse_data: fix cwd (#15417)

Fixes https://github.com/python/mypy/pull/15385#issuecomment-1587030261
---
 mypy/test/meta/test_parse_data.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/mypy/test/meta/test_parse_data.py b/mypy/test/meta/test_parse_data.py
index 6d9b32b96c7e6..a74b3d71d392b 100644
--- a/mypy/test/meta/test_parse_data.py
+++ b/mypy/test/meta/test_parse_data.py
@@ -16,13 +16,15 @@ def _dedent(self, s: str) -> str:
         return textwrap.dedent(s).lstrip()
 
     def _run_pytest(self, data_suite: str) -> str:
-        p = Path(test_data_prefix) / "check-__fixture__.test"
+        p_test_data = Path(test_data_prefix)
+        p_root = p_test_data.parent.parent
+        p = p_test_data / "check-__fixture__.test"
         assert not p.exists()
         try:
             p.write_text(data_suite)
             test_nodeid = f"mypy/test/testcheck.py::TypeCheckSuite::{p.name}"
             args = [sys.executable, "-m", "pytest", "-n", "0", "-s", test_nodeid]
-            proc = subprocess.run(args, capture_output=True, check=False)
+            proc = subprocess.run(args, cwd=p_root, capture_output=True, check=False)
             return proc.stdout.decode()
         finally:
             p.unlink()

From 61a7f3bfa37c433ac34f4f07dc224a1745577c82 Mon Sep 17 00:00:00 2001
From: Ilya Priven <ilya.konstantinov@gmail.com>
Date: Tue, 13 Jun 2023 18:54:33 -0400
Subject: [PATCH 026/129] Remove special casing for "cannot" in error messages
 (#15428)

Co-authored-by: hauntsaninja <hauntsaninja@gmail.com>
---
 mypy/test/helpers.py                      |   6 -
 test-data/unit/check-classes.test         |   4 +-
 test-data/unit/check-overloading.test     | 149 +++++++++++-----------
 test-data/unit/check-recursive-types.test |   4 +-
 test-data/unit/check-tuples.test          |  40 +++---
 test-data/unit/semanal-errors.test        |  63 +++++++--
 test-data/unit/semanal-statements.test    |   4 +-
 7 files changed, 151 insertions(+), 119 deletions(-)

diff --git a/mypy/test/helpers.py b/mypy/test/helpers.py
index 849ccdc376bd5..630ba305f349f 100644
--- a/mypy/test/helpers.py
+++ b/mypy/test/helpers.py
@@ -46,15 +46,9 @@ def run_mypy(args: list[str]) -> None:
 def assert_string_arrays_equal(expected: list[str], actual: list[str], msg: str) -> None:
     """Assert that two string arrays are equal.
 
-    We consider "can't" and "cannot" equivalent, by replacing the
-    former with the latter before comparing.
-
     Display any differences in a human-readable form.
     """
     actual = clean_up(actual)
-    actual = [line.replace("can't", "cannot") for line in actual]
-    expected = [line.replace("can't", "cannot") for line in expected]
-
     if actual != expected:
         num_skip_start = num_skipped_prefix_lines(expected, actual)
         num_skip_end = num_skipped_suffix_lines(expected, actual)
diff --git a/test-data/unit/check-classes.test b/test-data/unit/check-classes.test
index c2eddbc597a0a..cfd0cc3a4ec64 100644
--- a/test-data/unit/check-classes.test
+++ b/test-data/unit/check-classes.test
@@ -2019,7 +2019,7 @@ tmp/foo.pyi:5: note:          @overload
 tmp/foo.pyi:5: note:          def __add__(self, int, /) -> int
 tmp/foo.pyi:5: note:          @overload
 tmp/foo.pyi:5: note:          def __add__(self, str, /) -> str
-tmp/foo.pyi:5: note: Overloaded operator methods cannot have wider argument types in overrides
+tmp/foo.pyi:5: note: Overloaded operator methods can't have wider argument types in overrides
 
 [case testOperatorMethodOverrideWideningArgumentType]
 import typing
@@ -2138,7 +2138,7 @@ tmp/foo.pyi:8: note:          @overload
 tmp/foo.pyi:8: note:          def __add__(self, str, /) -> A
 tmp/foo.pyi:8: note:          @overload
 tmp/foo.pyi:8: note:          def __add__(self, type, /) -> A
-tmp/foo.pyi:8: note: Overloaded operator methods cannot have wider argument types in overrides
+tmp/foo.pyi:8: note: Overloaded operator methods can't have wider argument types in overrides
 
 [case testOverloadedOperatorMethodOverrideWithSwitchedItemOrder]
 from foo import *
diff --git a/test-data/unit/check-overloading.test b/test-data/unit/check-overloading.test
index 4209f4ec91640..96fbaa77514e5 100644
--- a/test-data/unit/check-overloading.test
+++ b/test-data/unit/check-overloading.test
@@ -4745,7 +4745,7 @@ main:12: note:          @overload
 main:12: note:          def __add__(self, Other, /) -> B
 main:12: note:          @overload
 main:12: note:          def __add__(self, A, /) -> A
-main:12: note: Overloaded operator methods cannot have wider argument types in overrides
+main:12: note: Overloaded operator methods can't have wider argument types in overrides
 main:32: note: Revealed type is "__main__.Other"
 
 [case testOverloadErrorMessageManyMatches]
@@ -5405,26 +5405,26 @@ if False:
 def f2(g): ...
 reveal_type(f2(A()))  # N: Revealed type is "__main__.A"
 reveal_type(f2(C()))  # E: No overload variant of "f2" matches argument type "C" \
-    # N: Possible overload variants: \
-    # N:     def f2(g: A) -> A \
-    # N:     def f2(g: B) -> B \
-    # N: Revealed type is "Any"
+                      # N: Possible overload variants: \
+                      # N:     def f2(g: A) -> A \
+                      # N:     def f2(g: B) -> B \
+                      # N: Revealed type is "Any"
 
 @overload
 def f3(g: A) -> A: ...
 @overload
 def f3(g: B) -> B: ...
-if maybe_true:  # E: Condition cannot be inferred, unable to merge overloads \
+if maybe_true:  # E: Condition can't be inferred, unable to merge overloads \
                 # E: Name "maybe_true" is not defined
     @overload
     def f3(g: C) -> C: ...
 def f3(g): ...
 reveal_type(f3(A()))  # N: Revealed type is "__main__.A"
 reveal_type(f3(C()))  # E: No overload variant of "f3" matches argument type "C" \
-    # N: Possible overload variants: \
-    # N:     def f3(g: A) -> A \
-    # N:     def f3(g: B) -> B \
-    # N: Revealed type is "Any"
+                      # N: Possible overload variants: \
+                      # N:     def f3(g: A) -> A \
+                      # N:     def f3(g: B) -> B \
+                      # N: Revealed type is "Any"
 
 if True:
     @overload
@@ -5731,10 +5731,10 @@ def f1(x): ...
 reveal_type(f1(A()))  # N: Revealed type is "__main__.A"
 reveal_type(f1(B()))  # N: Revealed type is "__main__.B"
 reveal_type(f1(D()))  # E: No overload variant of "f1" matches argument type "D" \
-    # N: Possible overload variants: \
-    # N:     def f1(x: A) -> A \
-    # N:     def f1(x: B) -> B \
-    # N: Revealed type is "Any"
+                      # N: Possible overload variants: \
+                      # N:     def f1(x: A) -> A \
+                      # N:     def f1(x: B) -> B \
+                      # N: Revealed type is "Any"
 
 @overload
 def f2(x: A) -> A: ...
@@ -5751,14 +5751,14 @@ def f2(x): ...
 reveal_type(f2(A()))  # N: Revealed type is "__main__.A"
 reveal_type(f2(B()))  # N: Revealed type is "__main__.B"
 reveal_type(f2(C()))  # E: No overload variant of "f2" matches argument type "C" \
-    # N: Possible overload variants: \
-    # N:     def f2(x: A) -> A \
-    # N:     def f2(x: B) -> B \
-    # N: Revealed type is "Any"
+                      # N: Possible overload variants: \
+                      # N:     def f2(x: A) -> A \
+                      # N:     def f2(x: B) -> B \
+                      # N: Revealed type is "Any"
 
 @overload  # E: Single overload definition, multiple required
 def f3(x: A) -> A: ...
-if maybe_true:  # E: Condition cannot be inferred, unable to merge overloads \
+if maybe_true:  # E: Condition can't be inferred, unable to merge overloads \
                 # E: Name "maybe_true" is not defined
     @overload
     def f3(x: B) -> B: ...
@@ -5771,13 +5771,13 @@ else:
 def f3(x): ...
 reveal_type(f3(A()))  # N: Revealed type is "__main__.A"
 reveal_type(f3(B()))  # E: No overload variant of "f3" matches argument type "B" \
-    # N: Possible overload variant: \
-    # N:     def f3(x: A) -> A \
-    # N: Revealed type is "Any"
+                      # N: Possible overload variant: \
+                      # N:     def f3(x: A) -> A \
+                      # N: Revealed type is "Any"
 
 @overload  # E: Single overload definition, multiple required
 def f4(x: A) -> A: ...
-if maybe_true:  # E: Condition cannot be inferred, unable to merge overloads \
+if maybe_true:  # E: Condition can't be inferred, unable to merge overloads \
                 # E: Name "maybe_true" is not defined
     @overload
     def f4(x: B) -> B: ...
@@ -5787,9 +5787,10 @@ else:
 def f4(x): ...
 reveal_type(f4(A()))  # N: Revealed type is "__main__.A"
 reveal_type(f4(B()))  # E: No overload variant of "f4" matches argument type "B" \
-    # N: Possible overload variant: \
-    # N:     def f4(x: A) -> A \
-    # N: Revealed type is "Any"
+                      # N: Possible overload variant: \
+                      # N:     def f4(x: A) -> A \
+                      # N: Revealed type is "Any"
+
 
 [case testOverloadIfElse3]
 # flags: --always-false False
@@ -5817,10 +5818,10 @@ else:
 def f1(x): ...
 reveal_type(f1(A()))  # N: Revealed type is "__main__.A"
 reveal_type(f1(B()))  # E: No overload variant of "f1" matches argument type "B" \
-    # N: Possible overload variants: \
-    # N:     def f1(x: A) -> A \
-    # N:     def f1(x: D) -> D \
-    # N: Revealed type is "Any"
+                      # N: Possible overload variants: \
+                      # N:     def f1(x: A) -> A \
+                      # N:     def f1(x: D) -> D \
+                      # N: Revealed type is "Any"
 reveal_type(f1(D()))  # N: Revealed type is "__main__.D"
 
 @overload  # E: Single overload definition, multiple required
@@ -5828,7 +5829,7 @@ def f2(x: A) -> A: ...
 if False:
     @overload
     def f2(x: B) -> B: ...
-elif maybe_true:  # E: Condition cannot be inferred, unable to merge overloads \
+elif maybe_true:  # E: Condition can't be inferred, unable to merge overloads \
                   # E: Name "maybe_true" is not defined
     @overload
     def f2(x: C) -> C: ...
@@ -5838,13 +5839,13 @@ else:
 def f2(x): ...
 reveal_type(f2(A()))  # N: Revealed type is "__main__.A"
 reveal_type(f2(C()))  # E: No overload variant of "f2" matches argument type "C" \
-    # N: Possible overload variant: \
-    # N:     def f2(x: A) -> A \
-    # N: Revealed type is "Any"
+                      # N: Possible overload variant: \
+                      # N:     def f2(x: A) -> A \
+                      # N: Revealed type is "Any"
 
 @overload  # E: Single overload definition, multiple required
 def f3(x: A) -> A: ...
-if maybe_true:  # E: Condition cannot be inferred, unable to merge overloads \
+if maybe_true:  # E: Condition can't be inferred, unable to merge overloads \
                 # E: Name "maybe_true" is not defined
     @overload
     def f3(x: B) -> B: ...
@@ -5857,14 +5858,14 @@ else:
 def f3(x): ...
 reveal_type(f3(A()))  # N: Revealed type is "__main__.A"
 reveal_type(f3(B()))  # E: No overload variant of "f3" matches argument type "B" \
-    # N: Possible overload variant: \
-    # N:     def f3(x: A) -> A \
-    # N: Revealed type is "Any"
+                      # N: Possible overload variant: \
+                      # N:     def f3(x: A) -> A \
+                      # N: Revealed type is "Any"
 
 def g(bool_var: bool) -> None:
     @overload
     def f4(x: A) -> A: ...
-    if bool_var:  # E: Condition cannot be inferred, unable to merge overloads
+    if bool_var:  # E: Condition can't be inferred, unable to merge overloads
         @overload
         def f4(x: B) -> B: ...
     elif maybe_true:  # E: Name "maybe_true" is not defined
@@ -5880,10 +5881,11 @@ def g(bool_var: bool) -> None:
     def f4(x): ...
     reveal_type(f4(E()))  # N: Revealed type is "__main__.E"
     reveal_type(f4(B()))  # E: No overload variant of "f4" matches argument type "B" \
-        # N: Possible overload variants: \
-        # N:     def f4(x: A) -> A \
-        # N:     def f4(x: E) -> E \
-        # N: Revealed type is "Any"
+                          # N: Possible overload variants: \
+                          # N:     def f4(x: A) -> A \
+                          # N:     def f4(x: E) -> E \
+                          # N: Revealed type is "Any"
+
 
 [case testOverloadIfSkipUnknownExecution]
 # flags: --always-true True
@@ -5901,14 +5903,14 @@ class D: ...
 
 @overload  # E: Single overload definition, multiple required
 def f1(x: A) -> A: ...
-if maybe_true:  # E: Condition cannot be inferred, unable to merge overloads \
+if maybe_true:  # E: Condition can't be inferred, unable to merge overloads \
                 # E: Name "maybe_true" is not defined
     @overload
     def f1(x: B) -> B: ...
 def f1(x): ...
 reveal_type(f1(A()))  # N: Revealed type is "__main__.A"
 
-if maybe_true:  # E: Condition cannot be inferred, unable to merge overloads \
+if maybe_true:  # E: Condition can't be inferred, unable to merge overloads \
                 # E: Name "maybe_true" is not defined
     @overload
     def f2(x: A) -> A: ...
@@ -5918,15 +5920,15 @@ def f2(x: B) -> B: ...
 def f2(x: C) -> C: ...
 def f2(x): ...
 reveal_type(f2(A()))  # E: No overload variant of "f2" matches argument type "A" \
-    # N: Possible overload variants: \
-    # N:     def f2(x: B) -> B \
-    # N:     def f2(x: C) -> C \
-    # N: Revealed type is "Any"
+                      # N: Possible overload variants: \
+                      # N:     def f2(x: B) -> B \
+                      # N:     def f2(x: C) -> C \
+                      # N: Revealed type is "Any"
 
 if True:
     @overload  # E: Single overload definition, multiple required
     def f3(x: A) -> A: ...
-    if maybe_true:  # E: Condition cannot be inferred, unable to merge overloads \
+    if maybe_true:  # E: Condition can't be inferred, unable to merge overloads \
                     # E: Name "maybe_true" is not defined
         @overload
         def f3(x: B) -> B: ...
@@ -5934,7 +5936,7 @@ if True:
 reveal_type(f3(A()))  # N: Revealed type is "__main__.A"
 
 if True:
-    if maybe_true:  # E: Condition cannot be inferred, unable to merge overloads \
+    if maybe_true:  # E: Condition can't be inferred, unable to merge overloads \
                     # E: Name "maybe_true" is not defined
         @overload
         def f4(x: A) -> A: ...
@@ -5944,10 +5946,10 @@ if True:
     def f4(x: C) -> C: ...
     def f4(x): ...
 reveal_type(f4(A()))  # E: No overload variant of "f4" matches argument type "A" \
-    # N: Possible overload variants: \
-    # N:     def f4(x: B) -> B \
-    # N:     def f4(x: C) -> C \
-    # N: Revealed type is "Any"
+                      # N: Possible overload variants: \
+                      # N:     def f4(x: B) -> B \
+                      # N:     def f4(x: C) -> C \
+                      # N: Revealed type is "Any"
 
 [case testOverloadIfDontSkipUnrelatedOverload]
 # flags: --always-true True
@@ -6187,16 +6189,16 @@ if False:
 def f8(x): ...
 reveal_type(f8(A()))  # N: Revealed type is "__main__.A"
 reveal_type(f8(C()))  # E: No overload variant of "f8" matches argument type "C" \
-    # N: Possible overload variants: \
-    # N:     def f8(x: A) -> A \
-    # N:     def f8(x: B) -> B \
-    # N: Revealed type is "Any"
+                      # N: Possible overload variants: \
+                      # N:     def f8(x: A) -> A \
+                      # N:     def f8(x: B) -> B \
+                      # N: Revealed type is "Any"
 
-if maybe_true:  # E: Condition cannot be inferred, unable to merge overloads \
+if maybe_true:  # E: Condition can't be inferred, unable to merge overloads \
                 # E: Name "maybe_true" is not defined
     @overload
     def f9(x: A) -> A: ...
-if another_maybe_true:  # E: Condition cannot be inferred, unable to merge overloads \
+if another_maybe_true:  # E: Condition can't be inferred, unable to merge overloads \
                         # E: Name "another_maybe_true" is not defined
     @overload
     def f9(x: B) -> B: ...
@@ -6206,18 +6208,18 @@ def f9(x: C) -> C: ...
 def f9(x: D) -> D: ...
 def f9(x): ...
 reveal_type(f9(A()))  # E: No overload variant of "f9" matches argument type "A" \
-    # N: Possible overload variants: \
-    # N:     def f9(x: C) -> C \
-    # N:     def f9(x: D) -> D \
-    # N: Revealed type is "Any"
+                      # N: Possible overload variants: \
+                      # N:     def f9(x: C) -> C \
+                      # N:     def f9(x: D) -> D \
+                      # N: Revealed type is "Any"
 reveal_type(f9(C()))  # N: Revealed type is "__main__.C"
 
 if True:
-    if maybe_true:  # E: Condition cannot be inferred, unable to merge overloads \
+    if maybe_true:  # E: Condition can't be inferred, unable to merge overloads \
                     # E: Name "maybe_true" is not defined
         @overload
         def f10(x: A) -> A: ...
-    if another_maybe_true:  # E: Condition cannot be inferred, unable to merge overloads \
+    if another_maybe_true:  # E: Condition can't be inferred, unable to merge overloads \
                             # E: Name "another_maybe_true" is not defined
         @overload
         def f10(x: B) -> B: ...
@@ -6227,10 +6229,10 @@ if True:
     def f10(x: D) -> D: ...
     def f10(x): ...
 reveal_type(f10(A()))  # E: No overload variant of "f10" matches argument type "A" \
-    # N: Possible overload variants: \
-    # N:     def f10(x: C) -> C \
-    # N:     def f10(x: D) -> D \
-    # N: Revealed type is "Any"
+                       # N: Possible overload variants: \
+                       # N:     def f10(x: C) -> C \
+                       # N:     def f10(x: D) -> D \
+                       # N: Revealed type is "Any"
 reveal_type(f10(C()))  # N: Revealed type is "__main__.C"
 
 if some_var:  # E: Name "some_var" is not defined
@@ -6251,6 +6253,7 @@ if True:
     def f12(x: B) -> B: ...
     def f12(x): ...
 reveal_type(f12(A()))  # N: Revealed type is "__main__.A"
+
 [typing fixtures/typing-medium.pyi]
 
 [case testOverloadIfUnconditionalFuncDef]
@@ -6406,7 +6409,7 @@ def f1(g: A) -> A: ...
 if True:
     @overload  # E: Single overload definition, multiple required
     def f1(g: B) -> B: ...
-    if maybe_true:  # E: Condition cannot be inferred, unable to merge overloads \
+    if maybe_true:  # E: Condition can't be inferred, unable to merge overloads \
                     # E: Name "maybe_true" is not defined
         @overload
         def f1(g: C) -> C: ...
@@ -6432,7 +6435,7 @@ if True:
     def f3(g: B) -> B: ...
     if True:
         pass  # Some other node
-        @overload  # E: Name "f3" already defined on line 32  \
+        @overload  # E: Name "f3" already defined on line 32 \
                    # E: An overloaded function outside a stub file must have an implementation
         def f3(g: C) -> C: ...
         @overload
diff --git a/test-data/unit/check-recursive-types.test b/test-data/unit/check-recursive-types.test
index 51f07cdccf8fa..dc1ae448c0d14 100644
--- a/test-data/unit/check-recursive-types.test
+++ b/test-data/unit/check-recursive-types.test
@@ -409,8 +409,8 @@ def local() -> None:
     x: L
     reveal_type(x)  # N: Revealed type is "builtins.list[Union[builtins.int, Any]]"
 
-S = Type[S]  # E: Type[...] cannot contain another Type[...]
-U = Type[Union[int, U]]  # E: Type[...] cannot contain another Type[...]
+S = Type[S]  # E: Type[...] can't contain another Type[...]
+U = Type[Union[int, U]]  # E: Type[...] can't contain another Type[...]
 x: U
 reveal_type(x)  # N: Revealed type is "Type[Any]"
 
diff --git a/test-data/unit/check-tuples.test b/test-data/unit/check-tuples.test
index e843532a25601..f8d6573a56fe4 100644
--- a/test-data/unit/check-tuples.test
+++ b/test-data/unit/check-tuples.test
@@ -1367,42 +1367,36 @@ reveal_type(a + b)  # N: Revealed type is "Tuple[builtins.int, builtins.str, bui
 from typing import Tuple
 
 # long initializer assignment with few mismatches
-t: Tuple[int, ...] = (1, 2, 3, 4, 5, 6, 7, 8, "str", "str", "str", 11) \
-                                                                    # E: Incompatible types in assignment (3 tuple items are incompatible) \
-                                                                    # N: Expression tuple item 8 has type "str"; "int" expected; \
-                                                                    # N: Expression tuple item 9 has type "str"; "int" expected; \
-                                                                    # N: Expression tuple item 10 has type "str"; "int" expected;
+t: Tuple[int, ...] = (1, 2, 3, 4, 5, 6, 7, 8, "str", "str", "str", 11) # E: Incompatible types in assignment (3 tuple items are incompatible) \
+                                                                       # N: Expression tuple item 8 has type "str"; "int" expected;  \
+                                                                       # N: Expression tuple item 9 has type "str"; "int" expected;  \
+                                                                       # N: Expression tuple item 10 has type "str"; "int" expected;
 
 # long initializer assignment with more mismatches
-t1: Tuple[int, ...] = (1, 2, 3, 4, 5, 6, 7, 8, "str", "str", "str", "str") \
-                                                                    # E: Incompatible types in assignment (4 tuple items are incompatible; 1 items are omitted) \
-                                                                    # N: Expression tuple item 8 has type "str"; "int" expected; \
-                                                                    # N: Expression tuple item 9 has type "str"; "int" expected; \
-                                                                    # N: Expression tuple item 10 has type "str"; "int" expected;
+t1: Tuple[int, ...] = (1, 2, 3, 4, 5, 6, 7, 8, "str", "str", "str", "str") # E: Incompatible types in assignment (4 tuple items are incompatible; 1 items are omitted) \
+                                                                           # N: Expression tuple item 8 has type "str"; "int" expected;  \
+                                                                           # N: Expression tuple item 9 has type "str"; "int" expected;  \
+                                                                           # N: Expression tuple item 10 has type "str"; "int" expected;
 
 # short tuple initializer assignment
-t2: Tuple[int, ...] = (1, 2, "s", 4) \
-                                # E: Incompatible types in assignment (expression has type "Tuple[int, int, str, int]", variable has type "Tuple[int, ...]")
+t2: Tuple[int, ...] = (1, 2, "s", 4) # E: Incompatible types in assignment (expression has type "Tuple[int, int, str, int]", variable has type "Tuple[int, ...]")
 
 # long initializer assignment with few mismatches, no ellipsis
-t3: Tuple[int, int, int, int, int, int, int, int, int, int, int, int] = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, "str", "str") \
-                                                                    # E: Incompatible types in assignment (2 tuple items are incompatible) \
-                                                                    # N: Expression tuple item 10 has type "str"; "int" expected; \
-                                                                    # N: Expression tuple item 11 has type "str"; "int" expected;
+t3: Tuple[int, int, int, int, int, int, int, int, int, int, int, int] = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, "str", "str") # E: Incompatible types in assignment (2 tuple items are incompatible) \
+                                                                                                                      # N: Expression tuple item 10 has type "str"; "int" expected;  \
+                                                                                                                      # N: Expression tuple item 11 has type "str"; "int" expected;
 
 # long initializer assignment with more mismatches, no ellipsis
-t4: Tuple[int, int, int, int, int, int, int, int, int, int, int, int] = (1, 2, 3, 4, 5, 6, 7, 8, "str", "str", "str", "str") \
-                                                                    # E: Incompatible types in assignment (4 tuple items are incompatible; 1 items are omitted) \
-                                                                    # N: Expression tuple item 8 has type "str"; "int" expected; \
-                                                                    # N: Expression tuple item 9 has type "str"; "int" expected; \
-                                                                    # N: Expression tuple item 10 has type "str"; "int" expected;
+t4: Tuple[int, int, int, int, int, int, int, int, int, int, int, int] = (1, 2, 3, 4, 5, 6, 7, 8, "str", "str", "str", "str") # E: Incompatible types in assignment (4 tuple items are incompatible; 1 items are omitted) \
+                                                                                                                             # N: Expression tuple item 8 has type "str"; "int" expected;  \
+                                                                                                                             # N: Expression tuple item 9 has type "str"; "int" expected;  \
+                                                                                                                             # N: Expression tuple item 10 has type "str"; "int" expected;
 
 # short tuple initializer assignment, no ellipsis
 t5: Tuple[int, int] = (1, 2, "s", 4)  # E: Incompatible types in assignment (expression has type "Tuple[int, int, str, int]", variable has type "Tuple[int, int]")
 
 # long initializer assignment with mismatched pairs
-t6: Tuple[int, int, int, int, int, int, int, int, int, int, int, int] = (1, 2, 3, 4, 5, 6, 7, 8, "str", "str", "str", "str", 1, 1, 1, 1, 1) \
-                                                                    # E: Incompatible types in assignment (expression has type Tuple[int, int, ... <15 more items>], variable has type Tuple[int, int, ... <10 more items>])
+t6: Tuple[int, int, int, int, int, int, int, int, int, int, int, int] = (1, 2, 3, 4, 5, 6, 7, 8, "str", "str", "str", "str", 1, 1, 1, 1, 1) # E: Incompatible types in assignment (expression has type Tuple[int, int, ... <15 more items>], variable has type Tuple[int, int, ... <10 more items>])
 
 [builtins fixtures/tuple.pyi]
 
diff --git a/test-data/unit/semanal-errors.test b/test-data/unit/semanal-errors.test
index 0c3de312cdfad..9c6ac2833c8bf 100644
--- a/test-data/unit/semanal-errors.test
+++ b/test-data/unit/semanal-errors.test
@@ -362,41 +362,55 @@ main:2: error: "yield" outside function
 1 = 1
 [out]
 main:1: error: can't assign to literal
+[out version>=3.8]
+main:1: error: cannot assign to literal
 [out version>=3.10]
-main:1: error: can't assign to literal here. Maybe you meant '==' instead of '='?
+main:1: error: cannot assign to literal here. Maybe you meant '==' instead of '='?
 
 [case testInvalidLvalues2]
 (1) = 1
 [out]
 main:1: error: can't assign to literal
+[out version>=3.8]
+main:1: error: cannot assign to literal
 [out version>=3.10]
-main:1: error: can't assign to literal here. Maybe you meant '==' instead of '='?
+main:1: error: cannot assign to literal here. Maybe you meant '==' instead of '='?
 
 [case testInvalidLvalues3]
 (1, 1) = 1
 [out]
 main:1: error: can't assign to literal
+[out version>=3.8]
+main:1: error: cannot assign to literal
 
 [case testInvalidLvalues4]
 [1, 1] = 1
 [out]
 main:1: error: can't assign to literal
+[out version>=3.8]
+main:1: error: cannot assign to literal
 
 [case testInvalidLvalues6]
 x = y = z = 1  # ok
 x, (y, 1) = 1
 [out]
 main:2: error: can't assign to literal
+[out version>=3.8]
+main:2: error: cannot assign to literal
 
 [case testInvalidLvalues7]
 x, [y, 1] = 1
 [out]
 main:1: error: can't assign to literal
+[out version>=3.8]
+main:1: error: cannot assign to literal
 
 [case testInvalidLvalues8]
 x, [y, [z, 1]] = 1
 [out]
 main:1: error: can't assign to literal
+[out version>=3.8]
+main:1: error: cannot assign to literal
 
 [case testInvalidLvalues9]
 x, (y) = 1 # ok
@@ -404,41 +418,53 @@ x, (y, (z, z)) = 1 # ok
 x, (y, (z, 1)) = 1
 [out]
 main:3: error: can't assign to literal
+[out version>=3.8]
+main:3: error: cannot assign to literal
 
 [case testInvalidLvalues10]
 x + x = 1
 [out]
 main:1: error: can't assign to operator
+[out version>=3.8]
+main:1: error: cannot assign to operator
 [out version>=3.10]
-main:1: error: can't assign to expression here. Maybe you meant '==' instead of '='?
+main:1: error: cannot assign to expression here. Maybe you meant '==' instead of '='?
 
 [case testInvalidLvalues11]
 -x = 1
 [out]
 main:1: error: can't assign to operator
+[out version>=3.8]
+main:1: error: cannot assign to operator
 [out version>=3.10]
-main:1: error: can't assign to expression here. Maybe you meant '==' instead of '='?
+main:1: error: cannot assign to expression here. Maybe you meant '==' instead of '='?
 
 [case testInvalidLvalues12]
 1.1 = 1
 [out]
 main:1: error: can't assign to literal
+[out version>=3.8]
+main:1: error: cannot assign to literal
 [out version>=3.10]
-main:1: error: can't assign to literal here. Maybe you meant '==' instead of '='?
+main:1: error: cannot assign to literal here. Maybe you meant '==' instead of '='?
 
 [case testInvalidLvalues13]
 'x' = 1
 [out]
 main:1: error: can't assign to literal
+[out version>=3.8]
+main:1: error: cannot assign to literal
 [out version>=3.10]
-main:1: error: can't assign to literal here. Maybe you meant '==' instead of '='?
+main:1: error: cannot assign to literal here. Maybe you meant '==' instead of '='?
 
 [case testInvalidLvalues14]
 x() = 1
 [out]
 main:1: error: can't assign to function call
+[out version>=3.8]
+main:1: error: cannot assign to function call
 [out version>=3.10]
-main:1: error: can't assign to function call here. Maybe you meant '==' instead of '='?
+main:1: error: cannot assign to function call here. Maybe you meant '==' instead of '='?
 
 [case testTwoStarExpressions]
 a, *b, *c = 1
@@ -490,20 +516,24 @@ main:2: error: Can use starred expression only as assignment target
 
 [case testInvalidDel1]
 x = 1
-del x(1)  # E: can't delete function call
+del x(1)
 [out]
+main:2: error: can't delete function call
+[out version>=3.8]
+main:2: error: cannot delete function call
 
 [case testInvalidDel2]
 x = 1
 del x + 1
 [out]
+main:2: error: can't delete operator
+[out version>=3.8]
 main:2: error: cannot delete operator
 [out version>=3.10]
 main:2: error: cannot delete expression
 
 [case testInvalidDel3]
 del z     # E: Name "z" is not defined
-[out]
 
 [case testFunctionTvarScope]
 
@@ -898,8 +928,10 @@ def f(): pass
 f() = 1 # type: int
 [out]
 main:3: error: can't assign to function call
+[out version>=3.8]
+main:3: error: cannot assign to function call
 [out version>=3.10]
-main:3: error: can't assign to function call here. Maybe you meant '==' instead of '='?
+main:3: error: cannot assign to function call here. Maybe you meant '==' instead of '='?
 
 [case testIndexedAssignmentWithTypeDeclaration]
 import typing
@@ -975,6 +1007,8 @@ x, y = 1, 2 # type: int # E: Tuple type expected for multiple variables
 a = 1
 a() = None # type: int
 [out]
+main:2: error: can't assign to function call
+[out version>=3.8]
 main:2: error: cannot assign to function call
 [out version>=3.10]
 main:2: error: cannot assign to function call here. Maybe you meant '==' instead of '='?
@@ -1275,8 +1309,11 @@ main:2: note: Did you forget to import it from "typing"? (Suggestion: "from typi
 
 [case testInvalidWithTarget]
 def f(): pass
-with f() as 1: pass  # E: can't assign to literal
+with f() as 1: pass
 [out]
+main:2: error: can't assign to literal
+[out version>=3.8]
+main:2: error: cannot assign to literal
 
 [case testInvalidTypeAnnotation]
 import typing
@@ -1291,8 +1328,10 @@ def f() -> None:
     f() = 1  # type: int
 [out]
 main:3: error: can't assign to function call
+[out version>=3.8]
+main:3: error: cannot assign to function call
 [out version>=3.10]
-main:3: error: can't assign to function call here. Maybe you meant '==' instead of '='?
+main:3: error: cannot assign to function call here. Maybe you meant '==' instead of '='?
 
 [case testInvalidReferenceToAttributeOfOuterClass]
 class A:
diff --git a/test-data/unit/semanal-statements.test b/test-data/unit/semanal-statements.test
index f602c236c949d..9b43a5b853c0c 100644
--- a/test-data/unit/semanal-statements.test
+++ b/test-data/unit/semanal-statements.test
@@ -558,8 +558,10 @@ def f(x, y) -> None:
     del x, y + 1
 [out]
 main:2: error: can't delete operator
+[out version>=3.8]
+main:2: error: cannot delete operator
 [out version>=3.10]
-main:2: error: can't delete expression
+main:2: error: cannot delete expression
 
 [case testTry]
 class c: pass

From 2a89f752dc174b4f0b99291c4a6bf10338dbbd5e Mon Sep 17 00:00:00 2001
From: Ilya Priven <ilya.konstantinov@gmail.com>
Date: Tue, 13 Jun 2023 18:56:22 -0400
Subject: [PATCH 027/129] [out] version checks must be against min version or
 higher (#15430)

---
 mypy/test/data.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/mypy/test/data.py b/mypy/test/data.py
index 86193e303d9c3..9b3931ee8be61 100644
--- a/mypy/test/data.py
+++ b/mypy/test/data.py
@@ -17,6 +17,7 @@
 
 import pytest
 
+from mypy import defaults
 from mypy.test.config import PREFIX, test_data_prefix, test_temp_dir
 
 root_dir = os.path.normpath(PREFIX)
@@ -166,6 +167,10 @@ def _item_fail(msg: str) -> NoReturn:
                         version = tuple(int(x) for x in version_str.split("."))
                     except ValueError:
                         _item_fail(f"{version_str!r} is not a valid python version")
+                    if version < defaults.PYTHON3_VERSION:
+                        _item_fail(
+                            f"Version check against {version}; must be >= {defaults.PYTHON3_VERSION}"
+                        )
                     if compare_op == ">=":
                         version_check = sys.version_info >= version
                     elif compare_op == "==":

From c63e873802fecfc3f817dceb94c729a6965e3489 Mon Sep 17 00:00:00 2001
From: Ilya Priven <ilya.konstantinov@gmail.com>
Date: Wed, 14 Jun 2023 07:11:23 -0400
Subject: [PATCH 028/129] docs: ref redirector (#15432)

Makes the HTML builder generate a _refs.html file that redirects
(global) refs (when provided as a hash i.e. `_refs.html#some-ref`) to
the appropriate document.

This allows tools (e.g. #15431) to link to well-known refs.
---
 docs/source/conf.py         |  2 +-
 docs/source/html_builder.py | 50 +++++++++++++++++++++++++++++++++++++
 2 files changed, 51 insertions(+), 1 deletion(-)
 create mode 100644 docs/source/html_builder.py

diff --git a/docs/source/conf.py b/docs/source/conf.py
index 80097ef5b3a89..683b2a6785b32 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -35,7 +35,7 @@
 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
 # ones.
-extensions = ["sphinx.ext.intersphinx"]
+extensions = ["sphinx.ext.intersphinx", "docs.source.html_builder"]
 
 # Add any paths that contain templates here, relative to this directory.
 templates_path = ["_templates"]
diff --git a/docs/source/html_builder.py b/docs/source/html_builder.py
new file mode 100644
index 0000000000000..49d58dda12ec5
--- /dev/null
+++ b/docs/source/html_builder.py
@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import json
+import textwrap
+from pathlib import Path
+from typing import Any
+
+from sphinx.addnodes import document
+from sphinx.application import Sphinx
+from sphinx.builders.html import StandaloneHTMLBuilder
+
+
+class MypyHTMLBuilder(StandaloneHTMLBuilder):
+    def __init__(self, app: Sphinx) -> None:
+        super().__init__(app)
+        self._ref_to_doc = {}
+
+    def write_doc(self, docname: str, doctree: document) -> None:
+        super().write_doc(docname, doctree)
+        self._ref_to_doc.update({_id: docname for _id in doctree.ids})
+
+    def _write_ref_redirector(self) -> None:
+        p = Path(self.outdir) / "_refs.html"
+        data = f"""
+        <html>
+        <body>
+        <script>
+        const ref_to_doc = {json.dumps(self._ref_to_doc)};
+        const hash = window.location.hash.substring(1);
+        const doc = ref_to_doc[hash];
+        if (doc) {{
+            window.location.href = doc + '.html' + '#' + hash;
+        }} else {{
+            window.document.innerText = 'Unknown reference: ' + hash;
+        }}
+        </script>
+        </body>
+        </html>
+        """
+        p.write_text(textwrap.dedent(data))
+
+    def finish(self) -> None:
+        super().finish()
+        self._write_ref_redirector()
+
+
+def setup(app: Sphinx) -> dict[str, Any]:
+    app.add_builder(MypyHTMLBuilder, override=True)
+
+    return {"version": "0.1", "parallel_read_safe": True, "parallel_write_safe": True}

From cdddc508c3533b960786841253e1aba251802081 Mon Sep 17 00:00:00 2001
From: Ivan Levkivskyi <levkivskyi@gmail.com>
Date: Wed, 14 Jun 2023 14:33:58 +0100
Subject: [PATCH 029/129] Fix dmypy run on Windows (#15429)

Fixes #10709

Two changes here:
* Add equality methods to `ErrorCode` because they may appear in options
snapshots
* Use stable comparison for option snapshots, since
`Options.apply_changes()` does some unrelated things with flags

Both are only relevant on Windows where options may roundtrip as:
`options -> snapshot -> pickle -> base64 -> unpickle -> apply_changes`.
---
 mypy/dmypy_server.py       |  2 +-
 mypy/errorcodes.py         |  8 ++++++++
 mypy/options.py            | 14 +++++++++++++-
 test-data/unit/daemon.test | 27 +++++++++++++++++++++++++++
 4 files changed, 49 insertions(+), 2 deletions(-)

diff --git a/mypy/dmypy_server.py b/mypy/dmypy_server.py
index c742f31164025..631aab4ccbc82 100644
--- a/mypy/dmypy_server.py
+++ b/mypy/dmypy_server.py
@@ -330,7 +330,7 @@ def cmd_run(
                         header=argparse.SUPPRESS,
                     )
             # Signal that we need to restart if the options have changed
-            if self.options_snapshot != options.snapshot():
+            if not options.compare_stable(self.options_snapshot):
                 return {"restart": "configuration changed"}
             if __version__ != version:
                 return {"restart": "mypy version changed"}
diff --git a/mypy/errorcodes.py b/mypy/errorcodes.py
index 50a82be9816d5..e87b04b6f4738 100644
--- a/mypy/errorcodes.py
+++ b/mypy/errorcodes.py
@@ -37,6 +37,14 @@ def __init__(
     def __str__(self) -> str:
         return f"<ErrorCode {self.code}>"
 
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ErrorCode):
+            return False
+        return self.code == other.code
+
+    def __hash__(self) -> int:
+        return hash((self.code,))
+
 
 ATTR_DEFINED: Final = ErrorCode("attr-defined", "Check that attribute exists", "General")
 NAME_DEFINED: Final = ErrorCode("name-defined", "Check that name is defined", "General")
diff --git a/mypy/options.py b/mypy/options.py
index 45591597ba69e..2785d2034c540 100644
--- a/mypy/options.py
+++ b/mypy/options.py
@@ -373,7 +373,7 @@ def use_or_syntax(self) -> bool:
     def new_semantic_analyzer(self) -> bool:
         return True
 
-    def snapshot(self) -> object:
+    def snapshot(self) -> dict[str, object]:
         """Produce a comparable snapshot of this Option"""
         # Under mypyc, we don't have a __dict__, so we need to do worse things.
         d = dict(getattr(self, "__dict__", ()))
@@ -388,6 +388,7 @@ def __repr__(self) -> str:
         return f"Options({pprint.pformat(self.snapshot())})"
 
     def apply_changes(self, changes: dict[str, object]) -> Options:
+        # Note: effects of this method *must* be idempotent.
         new_options = Options()
         # Under mypyc, we don't have a __dict__, so we need to do worse things.
         replace_object_state(new_options, self, copy_dict=True)
@@ -413,6 +414,17 @@ def apply_changes(self, changes: dict[str, object]) -> Options:
 
         return new_options
 
+    def compare_stable(self, other_snapshot: dict[str, object]) -> bool:
+        """Compare options in a way that is stable for snapshot() -> apply_changes() roundtrip.
+
+        This is needed because apply_changes() has non-trivial effects for some flags, so
+        Options().apply_changes(options.snapshot()) may result in a (slightly) different object.
+        """
+        return (
+            Options().apply_changes(self.snapshot()).snapshot()
+            == Options().apply_changes(other_snapshot).snapshot()
+        )
+
     def build_per_module_cache(self) -> None:
         self._per_module_cache = {}
 
diff --git a/test-data/unit/daemon.test b/test-data/unit/daemon.test
index c60068a44bece..424fc6d2b167b 100644
--- a/test-data/unit/daemon.test
+++ b/test-data/unit/daemon.test
@@ -28,6 +28,33 @@ Daemon stopped
 [file foo.py]
 def f(): pass
 
+[case testDaemonRunIgnoreMissingImports]
+$ dmypy run -- foo.py --follow-imports=error --ignore-missing-imports
+Daemon started
+Success: no issues found in 1 source file
+$ dmypy stop
+Daemon stopped
+[file foo.py]
+def f(): pass
+
+[case testDaemonRunErrorCodes]
+$ dmypy run -- foo.py --follow-imports=error --disable-error-code=type-abstract
+Daemon started
+Success: no issues found in 1 source file
+$ dmypy stop
+Daemon stopped
+[file foo.py]
+def f(): pass
+
+[case testDaemonRunCombinedOptions]
+$ dmypy run -- foo.py --follow-imports=error --ignore-missing-imports --disable-error-code=type-abstract
+Daemon started
+Success: no issues found in 1 source file
+$ dmypy stop
+Daemon stopped
+[file foo.py]
+def f(): pass
+
 [case testDaemonIgnoreConfigFiles]
 $ dmypy start -- --follow-imports=error
 Daemon started

From db97bbcede7ddeaecb3da31ee00f1812b115b8a4 Mon Sep 17 00:00:00 2001
From: Ivan Levkivskyi <levkivskyi@gmail.com>
Date: Wed, 14 Jun 2023 14:35:28 +0100
Subject: [PATCH 030/129] Use consistent anchors for error codes (#15435)

Fixes #15431

After this PR one will be able to easily find documentation for given
error code using
`https://mypy.readthedocs.io/en/stable/_refs.html#code-{code as reported
by mypy}`, for example
`https://mypy.readthedocs.io/en/stable/_refs.html#code-attr-defined`.
---
 docs/source/error_code_list.rst  | 76 ++++++++++++++++++++++++++++++++
 docs/source/error_code_list2.rst | 29 +++++++++++-
 docs/source/error_codes.rst      |  2 +-
 docs/source/html_builder.py      | 19 ++++++++
 4 files changed, 123 insertions(+), 3 deletions(-)

diff --git a/docs/source/error_code_list.rst b/docs/source/error_code_list.rst
index 54dc31f2cfcbb..1654c5910f981 100644
--- a/docs/source/error_code_list.rst
+++ b/docs/source/error_code_list.rst
@@ -8,6 +8,8 @@ with default options. See :ref:`error-codes` for general documentation
 about error codes. :ref:`error-codes-optional` documents additional
 error codes that you can enable.
 
+.. _code-attr-defined:
+
 Check that attribute exists [attr-defined]
 ------------------------------------------
 
@@ -43,6 +45,8 @@ A reference to a missing attribute is given the ``Any`` type. In the
 above example, the type of ``non_existent`` will be ``Any``, which can
 be important if you silence the error.
 
+.. _code-union-attr:
+
 Check that attribute exists in each union item [union-attr]
 -----------------------------------------------------------
 
@@ -75,6 +79,8 @@ You can often work around these errors by using ``assert isinstance(obj, ClassNa
 or ``assert obj is not None`` to tell mypy that you know that the type is more specific
 than what mypy thinks.
 
+.. _code-name-defined:
+
 Check that name is defined [name-defined]
 -----------------------------------------
 
@@ -89,6 +95,7 @@ This example accidentally calls ``sort()`` instead of :py:func:`sorted`:
 
     x = sort([3, 2, 4])  # Error: Name "sort" is not defined  [name-defined]
 
+.. _code-used-before-def:
 
 Check that a variable is not used before it's defined [used-before-def]
 -----------------------------------------------------------------------
@@ -105,6 +112,7 @@ Example:
     print(x)  # Error: Name "x" is used before definition [used-before-def]
     x = 123
 
+.. _code-call-arg:
 
 Check arguments in calls [call-arg]
 -----------------------------------
@@ -124,6 +132,8 @@ Example:
     greet('jack')  # OK
     greet('jill', 'jack')  # Error: Too many arguments for "greet"  [call-arg]
 
+.. _code-arg-type:
+
 Check argument types [arg-type]
 -------------------------------
 
@@ -144,6 +154,8 @@ Example:
     #        expected "list[int]"  [arg-type]
     print(first(t))
 
+.. _code-call-overload:
+
 Check calls to overloaded functions [call-overload]
 ---------------------------------------------------
 
@@ -175,6 +187,8 @@ Example:
    # Error: No overload variant of "inc_maybe" matches argument type "float"  [call-overload]
    inc_maybe(1.2)
 
+.. _code-valid-type:
+
 Check validity of types [valid-type]
 ------------------------------------
 
@@ -207,6 +221,8 @@ You can use :py:data:`~typing.Callable` as the type for callable objects:
         for x in objs:
             f(x)
 
+.. _code-var-annotated:
+
 Require annotation if variable type is unclear [var-annotated]
 --------------------------------------------------------------
 
@@ -239,6 +255,8 @@ To address this, we add an explicit annotation:
 
    reveal_type(Bundle().items)  # list[str]
 
+.. _code-override:
+
 Check validity of overrides [override]
 --------------------------------------
 
@@ -275,6 +293,8 @@ Example:
                   arg: bool) -> int:
            ...
 
+.. _code-return:
+
 Check that function returns a value [return]
 --------------------------------------------
 
@@ -303,6 +323,8 @@ Example:
         else:
             raise ValueError('not defined for zero')
 
+.. _code-return-value:
+
 Check that return value is compatible [return-value]
 ----------------------------------------------------
 
@@ -317,6 +339,8 @@ Example:
        # Error: Incompatible return value type (got "int", expected "str")  [return-value]
        return x + 1
 
+.. _code-assignment:
+
 Check types in assignment statement [assignment]
 ------------------------------------------------
 
@@ -339,6 +363,8 @@ Example:
     #        variable has type "str")  [assignment]
     r.name = 5
 
+.. _code-method-assign:
+
 Check that assignment target is not a method [method-assign]
 ------------------------------------------------------------
 
@@ -368,6 +394,8 @@ so only the second assignment will still generate an error.
 
     This error code is a subcode of the more general ``[assignment]`` code.
 
+.. _code-type-var:
+
 Check type variable values [type-var]
 -------------------------------------
 
@@ -390,6 +418,8 @@ Example:
     # Error: Value of type variable "T1" of "add" cannot be "str"  [type-var]
     add('x', 'y')
 
+.. _code-operator:
+
 Check uses of various operators [operator]
 ------------------------------------------
 
@@ -404,6 +434,8 @@ Example:
    # Error: Unsupported operand types for + ("int" and "str")  [operator]
    1 + 'x'
 
+.. _code-index:
+
 Check indexing operations [index]
 ---------------------------------
 
@@ -425,6 +457,8 @@ Example:
    # Error: Invalid index type "bytes" for "dict[str, int]"; expected type "str"  [index]
    a[b'x'] = 4
 
+.. _code-list-item:
+
 Check list items [list-item]
 ----------------------------
 
@@ -439,6 +473,8 @@ Example:
     # Error: List item 0 has incompatible type "int"; expected "str"  [list-item]
     a: list[str] = [0]
 
+.. _code-dict-item:
+
 Check dict items [dict-item]
 ----------------------------
 
@@ -453,6 +489,8 @@ Example:
     # Error: Dict entry 0 has incompatible type "str": "str"; expected "str": "int"  [dict-item]
     d: dict[str, int] = {'key': 'value'}
 
+.. _code-typeddict-item:
+
 Check TypedDict items [typeddict-item]
 --------------------------------------
 
@@ -477,6 +515,8 @@ Example:
     #        TypedDict item "x" has type "int")  [typeddict-item]
     p: Point = {'x': 1.2, 'y': 4}
 
+.. _code-typeddict-unknown-key:
+
 Check TypedDict Keys [typeddict-unknown-key]
 --------------------------------------------
 
@@ -533,6 +573,8 @@ runtime:
 
     This error code is a subcode of the wider ``[typeddict-item]`` code.
 
+.. _code-has-type:
+
 Check that type of target is known [has-type]
 ---------------------------------------------
 
@@ -572,6 +614,8 @@ the issue:
        def set_y(self) -> None:
            self.y: int = self.x  # Added annotation here
 
+.. _code-import:
+
 Check that import target can be found [import]
 ----------------------------------------------
 
@@ -587,6 +631,8 @@ Example:
 
 See :ref:`ignore-missing-imports` for how to work around these errors.
 
+.. _code-no-redef:
+
 Check that each name is defined once [no-redef]
 -----------------------------------------------
 
@@ -613,6 +659,8 @@ Example:
    #        (the first definition wins!)
    A('x')
 
+.. _code-func-returns-value:
+
 Check that called function returns a value [func-returns-value]
 ---------------------------------------------------------------
 
@@ -635,6 +683,8 @@ returns ``None``:
    if f():
         print("not false")
 
+.. _code-abstract:
+
 Check instantiation of abstract classes [abstract]
 --------------------------------------------------
 
@@ -666,6 +716,8 @@ Example:
     # Error: Cannot instantiate abstract class "Thing" with abstract attribute "save"  [abstract]
     t = Thing()
 
+.. _code-type-abstract:
+
 Safe handling of abstract type object types [type-abstract]
 -----------------------------------------------------------
 
@@ -692,6 +744,8 @@ Example:
    # Error: Only concrete class can be given where "Type[Config]" is expected [type-abstract]
    make_many(Config, 5)
 
+.. _code-safe-super:
+
 Check that call to an abstract method via super is valid [safe-super]
 ---------------------------------------------------------------------
 
@@ -714,6 +768,8 @@ will cause runtime errors, so mypy prevents you from doing so:
 Mypy considers the following as trivial bodies: a ``pass`` statement, a literal
 ellipsis ``...``, a docstring, and a ``raise NotImplementedError`` statement.
 
+.. _code-valid-newtype:
+
 Check the target of NewType [valid-newtype]
 -------------------------------------------
 
@@ -738,6 +794,8 @@ To work around the issue, you can either give mypy access to the sources
 for ``acme`` or create a stub file for the module.  See :ref:`ignore-missing-imports`
 for more information.
 
+.. _code-exit-return:
+
 Check the return type of __exit__ [exit-return]
 -----------------------------------------------
 
@@ -794,6 +852,8 @@ You can also use ``None``:
        def __exit__(self, exc, value, tb) -> None:  # Also OK
            print('exit')
 
+.. _code-name-match:
+
 Check that naming is consistent [name-match]
 --------------------------------------------
 
@@ -807,6 +867,8 @@ consistently when using the call-based syntax. Example:
     # Error: First argument to namedtuple() should be "Point2D", not "Point"
     Point2D = NamedTuple("Point", [("x", int), ("y", int)])
 
+.. _code-literal-required:
+
 Check that literal is used where expected [literal-required]
 ------------------------------------------------------------
 
@@ -836,6 +898,8 @@ or ``Literal`` variables. Example:
        #   expected one of ("x", "y")  [literal-required]
        p[key]
 
+.. _code-no-overload-impl:
+
 Check that overloaded functions have an implementation [no-overload-impl]
 -------------------------------------------------------------------------
 
@@ -858,6 +922,8 @@ implementation.
    def func(value):
        pass  # actual implementation
 
+.. _code-unused-coroutine:
+
 Check that coroutine return value is used [unused-coroutine]
 ------------------------------------------------------------
 
@@ -881,6 +947,8 @@ otherwise unused variable:
 
        _ = f()  # No error
 
+.. _code-assert-type:
+
 Check types in assert_type [assert-type]
 ----------------------------------------
 
@@ -895,6 +963,8 @@ the provided type.
 
    assert_type([1], list[str])  # Error
 
+.. _code-truthy-function:
+
 Check that function isn't used in boolean context [truthy-function]
 -------------------------------------------------------------------
 
@@ -908,6 +978,8 @@ Functions will always evaluate to true in boolean contexts.
     if f:  # Error: Function "Callable[[], Any]" could always be true in boolean context  [truthy-function]
         pass
 
+.. _code-str-bytes-safe:
+
 Check for implicit bytes coercions [str-bytes-safe]
 -------------------------------------------------------------------
 
@@ -926,6 +998,8 @@ Warn about cases where a bytes object may be converted to a string in an unexpec
     print(f"The alphabet starts with {b!r}")  # The alphabet starts with b'abc'
     print(f"The alphabet starts with {b.decode('utf-8')}")  # The alphabet starts with abc
 
+.. _code-syntax:
+
 Report syntax errors [syntax]
 -----------------------------
 
@@ -933,6 +1007,8 @@ If the code being checked is not syntactically valid, mypy issues a
 syntax error. Most, but not all, syntax errors are *blocking errors*:
 they can't be ignored with a ``# type: ignore`` comment.
 
+.. _code-misc:
+
 Miscellaneous checks [misc]
 ---------------------------
 
diff --git a/docs/source/error_code_list2.rst b/docs/source/error_code_list2.rst
index 8be2ac0b1d730..11f463f93018e 100644
--- a/docs/source/error_code_list2.rst
+++ b/docs/source/error_code_list2.rst
@@ -15,6 +15,8 @@ error codes that are enabled by default.
    options by using a :ref:`configuration file <config-file>` or
    :ref:`command-line options <command-line>`.
 
+.. _code-type-arg:
+
 Check that type arguments exist [type-arg]
 ------------------------------------------
 
@@ -34,6 +36,8 @@ Example:
     def remove_dups(items: list) -> list:
         ...
 
+.. _code-no-untyped-def:
+
 Check that every function has an annotation [no-untyped-def]
 ------------------------------------------------------------
 
@@ -62,6 +66,8 @@ Example:
          def __init__(self) -> None:
              self.value = 0
 
+.. _code-redundant-cast:
+
 Check that cast is not redundant [redundant-cast]
 -------------------------------------------------
 
@@ -82,6 +88,8 @@ Example:
         # Error: Redundant cast to "int"  [redundant-cast]
         return cast(int, x)
 
+.. _code-redundant-self:
+
 Check that methods do not have redundant Self annotations [redundant-self]
 --------------------------------------------------------------------------
 
@@ -104,6 +112,8 @@ Example:
        def copy(self: Self) -> Self:
            return type(self)()
 
+.. _code-comparison-overlap:
+
 Check that comparisons are overlapping [comparison-overlap]
 -----------------------------------------------------------
 
@@ -135,6 +145,8 @@ literal:
     def is_magic(x: bytes) -> bool:
         return x == b'magic'  # OK
 
+.. _code-no-untyped-call:
+
 Check that no untyped functions are called [no-untyped-call]
 ------------------------------------------------------------
 
@@ -154,6 +166,7 @@ Example:
     def bad():
         ...
 
+.. _code-no-any-return:
 
 Check that function does not return Any value [no-any-return]
 -------------------------------------------------------------
@@ -175,6 +188,8 @@ Example:
         # Error: Returning Any from function declared to return "str"  [no-any-return]
         return fields(x)[0]
 
+.. _code-no-any-unimported:
+
 Check that types have no Any components due to missing imports [no-any-unimported]
 ----------------------------------------------------------------------------------
 
@@ -195,6 +210,8 @@ that ``Cat`` falls back to ``Any`` in a type annotation:
     def feed(cat: Cat) -> None:
         ...
 
+.. _code-unreachable:
+
 Check that statement or expression is unreachable [unreachable]
 ---------------------------------------------------------------
 
@@ -214,6 +231,8 @@ incorrect control flow or conditional checks that are accidentally always true o
         # Error: Statement is unreachable  [unreachable]
         print('unreachable')
 
+.. _code-redundant-expr:
+
 Check that expression is redundant [redundant-expr]
 ---------------------------------------------------
 
@@ -236,6 +255,8 @@ mypy generates an error if it thinks that an expression is redundant.
         [i for i in range(x) if isinstance(i, int)]
 
 
+.. _code-truthy-bool:
+
 Check that expression is not implicitly true in boolean context [truthy-bool]
 -----------------------------------------------------------------------------
 
@@ -259,6 +280,7 @@ Using an iterable value in a boolean context has a separate error code
     if foo:
          ...
 
+.. _code-truthy-iterable:
 
 Check that iterable is not implicitly true in boolean context [truthy-iterable]
 -------------------------------------------------------------------------------
@@ -286,8 +308,7 @@ items`` check is actually valid. If that is the case, it is
 recommended to annotate ``items`` as ``Collection[int]`` instead of
 ``Iterable[int]``.
 
-
-.. _ignore-without-code:
+.. _code-ignore-without-code:
 
 Check that ``# type: ignore`` include an error code [ignore-without-code]
 -------------------------------------------------------------------------
@@ -319,6 +340,8 @@ Example:
     # Error: "Foo" has no attribute "nme"; maybe "name"?
     f.nme = 42  # type: ignore[assignment]
 
+.. _code-unused-awaitable:
+
 Check that awaitable return value is used [unused-awaitable]
 ------------------------------------------------------------
 
@@ -348,6 +371,8 @@ silence the error:
     async def g() -> None:
         _ = asyncio.create_task(f())  # No error
 
+.. _code-unused-ignore:
+
 Check that ``# type: ignore`` comment is used [unused-ignore]
 -------------------------------------------------------------
 
diff --git a/docs/source/error_codes.rst b/docs/source/error_codes.rst
index c8a2728b5697d..65ae0e5816e83 100644
--- a/docs/source/error_codes.rst
+++ b/docs/source/error_codes.rst
@@ -32,7 +32,7 @@ or config ``hide_error_codes = True`` to hide error codes. Error codes are shown
    prog.py:1: error: "str" has no attribute "trim"  [attr-defined]
 
 It's also possible to require error codes for ``type: ignore`` comments.
-See :ref:`ignore-without-code<ignore-without-code>` for more information.
+See :ref:`ignore-without-code<code-ignore-without-code>` for more information.
 
 
 .. _silence-error-codes:
diff --git a/docs/source/html_builder.py b/docs/source/html_builder.py
index 49d58dda12ec5..efe1fcaa48fad 100644
--- a/docs/source/html_builder.py
+++ b/docs/source/html_builder.py
@@ -9,6 +9,8 @@
 from sphinx.application import Sphinx
 from sphinx.builders.html import StandaloneHTMLBuilder
 
+from mypy.errorcodes import error_codes
+
 
 class MypyHTMLBuilder(StandaloneHTMLBuilder):
     def __init__(self, app: Sphinx) -> None:
@@ -20,6 +22,23 @@ def write_doc(self, docname: str, doctree: document) -> None:
         self._ref_to_doc.update({_id: docname for _id in doctree.ids})
 
     def _write_ref_redirector(self) -> None:
+        known_missing = {
+            # TODO: fix these before next release
+            "annotation-unchecked",
+            "empty-body",
+            "possibly-undefined",
+            "str-format",
+            "top-level-await",
+        }
+        missing_error_codes = {
+            c
+            for c in error_codes
+            if f"code-{c}" not in self._ref_to_doc and c not in known_missing
+        }
+        if missing_error_codes:
+            raise ValueError(
+                f"Some error codes are not documented: {', '.join(sorted(missing_error_codes))}"
+            )
         p = Path(self.outdir) / "_refs.html"
         data = f"""
         <html>

From e14cddbe31c9437502acef022dca376a25d0b50d Mon Sep 17 00:00:00 2001
From: Ivan Levkivskyi <levkivskyi@gmail.com>
Date: Wed, 14 Jun 2023 16:18:09 +0100
Subject: [PATCH 031/129] Fix readthedocs build (#15437)

I initially included an error (removed allowlisted error code that is
not covered), to verify it will be caught.

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
---
 .github/workflows/docs.yml  |  1 +
 docs/source/html_builder.py | 11 ++++++++---
 tox.ini                     |  2 ++
 3 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 8851f7fbb0f38..3e06b5e909f13 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -20,6 +20,7 @@ jobs:
     env:
       TOXENV: docs
       TOX_SKIP_MISSING_INTERPRETERS: False
+      VERIFY_MYPY_ERROR_CODES: 1
     steps:
       - uses: actions/checkout@v3
       - uses: actions/setup-python@v4
diff --git a/docs/source/html_builder.py b/docs/source/html_builder.py
index efe1fcaa48fad..405b80ac53d22 100644
--- a/docs/source/html_builder.py
+++ b/docs/source/html_builder.py
@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import json
+import os
 import textwrap
 from pathlib import Path
 from typing import Any
@@ -9,8 +10,6 @@
 from sphinx.application import Sphinx
 from sphinx.builders.html import StandaloneHTMLBuilder
 
-from mypy.errorcodes import error_codes
-
 
 class MypyHTMLBuilder(StandaloneHTMLBuilder):
     def __init__(self, app: Sphinx) -> None:
@@ -21,7 +20,9 @@ def write_doc(self, docname: str, doctree: document) -> None:
         super().write_doc(docname, doctree)
         self._ref_to_doc.update({_id: docname for _id in doctree.ids})
 
-    def _write_ref_redirector(self) -> None:
+    def _verify_error_codes(self) -> None:
+        from mypy.errorcodes import error_codes
+
         known_missing = {
             # TODO: fix these before next release
             "annotation-unchecked",
@@ -39,6 +40,10 @@ def _write_ref_redirector(self) -> None:
             raise ValueError(
                 f"Some error codes are not documented: {', '.join(sorted(missing_error_codes))}"
             )
+
+    def _write_ref_redirector(self) -> None:
+        if os.getenv("VERIFY_MYPY_ERROR_CODES"):
+            self._verify_error_codes()
         p = Path(self.outdir) / "_refs.html"
         data = f"""
         <html>
diff --git a/tox.ini b/tox.ini
index 6d64cebaec6da..2ddda8281beb0 100644
--- a/tox.ini
+++ b/tox.ini
@@ -33,6 +33,8 @@ commands =
 
 [testenv:docs]
 description = invoke sphinx-build to build the HTML docs
+passenv =
+    VERIFY_MYPY_ERROR_CODES
 deps = -rdocs/requirements-docs.txt
 commands =
     sphinx-build -d "{toxworkdir}/docs_doctree" docs/source "{toxworkdir}/docs_out" --color -W -bhtml {posargs}

From 66b96ed54b255495288ba539e3fd1f54f21d4abe Mon Sep 17 00:00:00 2001
From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
Date: Thu, 15 Jun 2023 16:03:14 +0200
Subject: [PATCH 032/129] Additional validation for TypeVar defaults (PEP 696)
 (#15442)

Check that `default` type is a subtype of `bound` or one of the
constraint types.

Add `default` to nodes `__match_args__`. Missed that initially.

Ref: #14851
---
 mypy/checkexpr.py                          | 9 +++++++++
 mypy/nodes.py                              | 6 +++---
 test-data/unit/check-typevar-defaults.test | 9 +++++++++
 3 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py
index cd0ff11001831..4b204a80c1308 100644
--- a/mypy/checkexpr.py
+++ b/mypy/checkexpr.py
@@ -5197,6 +5197,15 @@ def visit_temp_node(self, e: TempNode) -> Type:
         return e.type
 
     def visit_type_var_expr(self, e: TypeVarExpr) -> Type:
+        p_default = get_proper_type(e.default)
+        if not (
+            isinstance(p_default, AnyType)
+            and p_default.type_of_any == TypeOfAny.from_omitted_generics
+        ):
+            if not is_subtype(p_default, e.upper_bound):
+                self.chk.fail("TypeVar default must be a subtype of the bound type", e)
+            if e.values and not any(p_default == value for value in e.values):
+                self.chk.fail("TypeVar default must be one of the constraint types", e)
         return AnyType(TypeOfAny.special_form)
 
     def visit_paramspec_expr(self, e: ParamSpecExpr) -> Type:
diff --git a/mypy/nodes.py b/mypy/nodes.py
index 8457e39b6aa16..4e29a434d7fe4 100644
--- a/mypy/nodes.py
+++ b/mypy/nodes.py
@@ -2493,7 +2493,7 @@ class TypeVarExpr(TypeVarLikeExpr):
 
     __slots__ = ("values",)
 
-    __match_args__ = ("name", "values", "upper_bound")
+    __match_args__ = ("name", "values", "upper_bound", "default")
 
     # Value restriction: only types in the list are valid as values. If the
     # list is empty, there is no restriction.
@@ -2541,7 +2541,7 @@ def deserialize(cls, data: JsonDict) -> TypeVarExpr:
 class ParamSpecExpr(TypeVarLikeExpr):
     __slots__ = ()
 
-    __match_args__ = ("name", "upper_bound")
+    __match_args__ = ("name", "upper_bound", "default")
 
     def accept(self, visitor: ExpressionVisitor[T]) -> T:
         return visitor.visit_paramspec_expr(self)
@@ -2575,7 +2575,7 @@ class TypeVarTupleExpr(TypeVarLikeExpr):
 
     tuple_fallback: mypy.types.Instance
 
-    __match_args__ = ("name", "upper_bound")
+    __match_args__ = ("name", "upper_bound", "default")
 
     def __init__(
         self,
diff --git a/test-data/unit/check-typevar-defaults.test b/test-data/unit/check-typevar-defaults.test
index 7bc2d4089ecd9..514186aa7518f 100644
--- a/test-data/unit/check-typevar-defaults.test
+++ b/test-data/unit/check-typevar-defaults.test
@@ -72,3 +72,12 @@ Ts1 = TypeVarTuple("Ts1", default=2) # E: The default argument to TypeVarTuple m
 Ts2 = TypeVarTuple("Ts2", default=int)  # E: The default argument to TypeVarTuple must be an Unpacked tuple
 Ts3 = TypeVarTuple("Ts3", default=Tuple[int])  # E: The default argument to TypeVarTuple must be an Unpacked tuple
 [builtins fixtures/tuple.pyi]
+
+[case testTypeVarDefaultsInvalid2]
+from typing import TypeVar, List, Union
+
+T1 = TypeVar("T1", bound=str, default=int)  # E: TypeVar default must be a subtype of the bound type
+T2 = TypeVar("T2", bound=List[str], default=List[int])  # E: TypeVar default must be a subtype of the bound type
+T3 = TypeVar("T3", int, str, default=bytes)  # E: TypeVar default must be one of the constraint types
+T4 = TypeVar("T4", int, str, default=Union[int, str])  # E: TypeVar default must be one of the constraint types
+T5 = TypeVar("T5", float, str, default=int)  # E: TypeVar default must be one of the constraint types

From 59a6c5e73de6b92faa2c25e39856fb43380f82ed Mon Sep 17 00:00:00 2001
From: AlexWaygood <alex.waygood@gmail.com>
Date: Thu, 15 Jun 2023 15:58:14 +0100
Subject: [PATCH 033/129] Sync typeshed

Source commit:
https://github.com/python/typeshed/commit/c38fc45d9c9340eb11e6dd279f460f8a1b3d5d7b
---
 mypy/typeshed/stdlib/VERSIONS                 |   4 +-
 mypy/typeshed/stdlib/_ast.pyi                 |  51 +++-
 mypy/typeshed/stdlib/_csv.pyi                 |   4 +
 mypy/typeshed/stdlib/_ctypes.pyi              |   9 +-
 mypy/typeshed/stdlib/_socket.pyi              |  25 ++
 mypy/typeshed/stdlib/_thread.pyi              |   3 +
 mypy/typeshed/stdlib/_winapi.pyi              |  31 +++
 mypy/typeshed/stdlib/argparse.pyi             |  50 +++-
 mypy/typeshed/stdlib/ast.pyi                  |   4 +-
 mypy/typeshed/stdlib/builtins.pyi             | 122 ++++++++-
 mypy/typeshed/stdlib/calendar.pyi             |  75 +++++-
 mypy/typeshed/stdlib/csv.pyi                  |   5 +
 mypy/typeshed/stdlib/ctypes/__init__.pyi      |   3 +
 mypy/typeshed/stdlib/dis.pyi                  |   5 +-
 mypy/typeshed/stdlib/distutils/__init__.pyi   |   5 +
 mypy/typeshed/stdlib/email/generator.pyi      |   8 +-
 mypy/typeshed/stdlib/email/policy.pyi         |   3 +-
 mypy/typeshed/stdlib/fcntl.pyi                |   5 +-
 mypy/typeshed/stdlib/ftplib.pyi               |  15 +-
 mypy/typeshed/stdlib/functools.pyi            |  73 +++--
 mypy/typeshed/stdlib/http/__init__.pyi        |  11 +
 mypy/typeshed/stdlib/locale.pyi               |  11 +-
 .../stdlib/multiprocessing/connection.pyi     |   7 +-
 .../stdlib/multiprocessing/queues.pyi         |   2 +
 mypy/typeshed/stdlib/opcode.pyi               |  12 +-
 mypy/typeshed/stdlib/pathlib.pyi              |  28 +-
 mypy/typeshed/stdlib/pdb.pyi                  |   5 +-
 mypy/typeshed/stdlib/pkgutil.pyi              |  13 +-
 mypy/typeshed/stdlib/shutil.pyi               |   5 +-
 mypy/typeshed/stdlib/socket.pyi               |  35 +++
 mypy/typeshed/stdlib/socketserver.pyi         |   5 +
 mypy/typeshed/stdlib/sys.pyi                  |  12 +-
 mypy/typeshed/stdlib/tarfile.pyi              |  90 ++++++-
 mypy/typeshed/stdlib/tempfile.pyi             | 255 ++++++++++++++----
 mypy/typeshed/stdlib/threading.pyi            |   7 +
 mypy/typeshed/stdlib/token.pyi                |   9 +
 mypy/typeshed/stdlib/tokenize.pyi             |   3 +
 mypy/typeshed/stdlib/types.pyi                |   8 +-
 mypy/typeshed/stdlib/typing.pyi               |   5 +-
 mypy/typeshed/stdlib/uuid.pyi                 |   3 +
 mypy/typeshed/stdlib/webbrowser.pyi           |  11 +-
 mypy/typeshed/stdlib/zipimport.pyi            |   6 +-
 mypy/typeshed/stdlib/zoneinfo/__init__.pyi    |   6 +-
 43 files changed, 899 insertions(+), 150 deletions(-)

diff --git a/mypy/typeshed/stdlib/VERSIONS b/mypy/typeshed/stdlib/VERSIONS
index 86e8da78677c8..49433e346765e 100644
--- a/mypy/typeshed/stdlib/VERSIONS
+++ b/mypy/typeshed/stdlib/VERSIONS
@@ -112,7 +112,7 @@ dbm: 2.7-
 decimal: 2.7-
 difflib: 2.7-
 dis: 2.7-
-distutils: 2.7-
+distutils: 2.7-3.11
 distutils.command.bdist_msi: 2.7-3.10
 distutils.command.bdist_wininst: 2.7-3.9
 doctest: 2.7-
@@ -147,7 +147,7 @@ html: 3.0-
 http: 3.0-
 imaplib: 2.7-
 imghdr: 2.7-
-imp: 2.7-
+imp: 2.7-3.11
 importlib: 2.7-
 importlib.metadata: 3.8-
 importlib.metadata._meta: 3.10-
diff --git a/mypy/typeshed/stdlib/_ast.pyi b/mypy/typeshed/stdlib/_ast.pyi
index 7bc47266d713e..05e2a08fdc885 100644
--- a/mypy/typeshed/stdlib/_ast.pyi
+++ b/mypy/typeshed/stdlib/_ast.pyi
@@ -1,13 +1,14 @@
 import sys
+import typing_extensions
 from typing import Any, ClassVar
-from typing_extensions import Literal, TypeAlias
+from typing_extensions import Literal
 
 PyCF_ONLY_AST: Literal[1024]
 if sys.version_info >= (3, 8):
     PyCF_TYPE_COMMENTS: Literal[4096]
     PyCF_ALLOW_TOP_LEVEL_AWAIT: Literal[8192]
 
-_Identifier: TypeAlias = str
+_Identifier: typing_extensions.TypeAlias = str
 
 class AST:
     if sys.version_info >= (3, 10):
@@ -59,31 +60,43 @@ class Expression(mod):
 class stmt(AST): ...
 
 class FunctionDef(stmt):
-    if sys.version_info >= (3, 10):
+    if sys.version_info >= (3, 12):
+        __match_args__ = ("name", "args", "body", "decorator_list", "returns", "type_comment", "type_params")
+    elif sys.version_info >= (3, 10):
         __match_args__ = ("name", "args", "body", "decorator_list", "returns", "type_comment")
     name: _Identifier
     args: arguments
     body: list[stmt]
     decorator_list: list[expr]
     returns: expr | None
+    if sys.version_info >= (3, 12):
+        type_params: list[type_param]
 
 class AsyncFunctionDef(stmt):
-    if sys.version_info >= (3, 10):
+    if sys.version_info >= (3, 12):
+        __match_args__ = ("name", "args", "body", "decorator_list", "returns", "type_comment", "type_params")
+    elif sys.version_info >= (3, 10):
         __match_args__ = ("name", "args", "body", "decorator_list", "returns", "type_comment")
     name: _Identifier
     args: arguments
     body: list[stmt]
     decorator_list: list[expr]
     returns: expr | None
+    if sys.version_info >= (3, 12):
+        type_params: list[type_param]
 
 class ClassDef(stmt):
-    if sys.version_info >= (3, 10):
+    if sys.version_info >= (3, 12):
+        __match_args__ = ("name", "bases", "keywords", "body", "decorator_list", "type_params")
+    elif sys.version_info >= (3, 10):
         __match_args__ = ("name", "bases", "keywords", "body", "decorator_list")
     name: _Identifier
     bases: list[expr]
     keywords: list[keyword]
     body: list[stmt]
     decorator_list: list[expr]
+    if sys.version_info >= (3, 12):
+        type_params: list[type_param]
 
 class Return(stmt):
     if sys.version_info >= (3, 10):
@@ -366,10 +379,10 @@ class Attribute(expr):
     ctx: expr_context
 
 if sys.version_info >= (3, 9):
-    _Slice: TypeAlias = expr
+    _Slice: typing_extensions.TypeAlias = expr
 else:
     class slice(AST): ...
-    _Slice: TypeAlias = slice
+    _Slice: typing_extensions.TypeAlias = slice
 
 class Slice(_Slice):
     if sys.version_info >= (3, 10):
@@ -526,7 +539,7 @@ if sys.version_info >= (3, 10):
 
     class pattern(AST): ...
     # Without the alias, Pyright complains variables named pattern are recursively defined
-    _Pattern: TypeAlias = pattern
+    _Pattern: typing_extensions.TypeAlias = pattern
 
     class match_case(AST):
         __match_args__ = ("pattern", "guard", "body")
@@ -571,3 +584,25 @@ if sys.version_info >= (3, 10):
     class MatchOr(pattern):
         __match_args__ = ("patterns",)
         patterns: list[pattern]
+
+if sys.version_info >= (3, 12):
+    class type_param(AST): ...
+
+    class TypeVar(type_param):
+        __match_args__ = ("name", "bound")
+        name: _Identifier
+        bound: expr | None
+
+    class ParamSpec(type_param):
+        __match_args__ = ("name",)
+        name: _Identifier
+
+    class TypeVarTuple(type_param):
+        __match_args__ = ("name",)
+        name: _Identifier
+
+    class TypeAlias(stmt):
+        __match_args__ = ("name", "typeparams", "value")
+        name: Name
+        type_params: list[type_param]
+        value: expr
diff --git a/mypy/typeshed/stdlib/_csv.pyi b/mypy/typeshed/stdlib/_csv.pyi
index c9b9f47e6217b..19ea487e15302 100644
--- a/mypy/typeshed/stdlib/_csv.pyi
+++ b/mypy/typeshed/stdlib/_csv.pyi
@@ -1,3 +1,4 @@
+import sys
 from _typeshed import SupportsWrite
 from collections.abc import Iterable, Iterator
 from typing import Any
@@ -9,6 +10,9 @@ QUOTE_ALL: Literal[1]
 QUOTE_MINIMAL: Literal[0]
 QUOTE_NONE: Literal[3]
 QUOTE_NONNUMERIC: Literal[2]
+if sys.version_info >= (3, 12):
+    QUOTE_STRINGS: Literal[4]
+    QUOTE_NOTNULL: Literal[5]
 
 # Ideally this would be `QUOTE_ALL | QUOTE_MINIMAL | QUOTE_NONE | QUOTE_NONNUMERIC`
 # However, using literals in situations like these can cause false-positives (see #7258)
diff --git a/mypy/typeshed/stdlib/_ctypes.pyi b/mypy/typeshed/stdlib/_ctypes.pyi
index 8e8bcbe84bd4d..25d604218a00d 100644
--- a/mypy/typeshed/stdlib/_ctypes.pyi
+++ b/mypy/typeshed/stdlib/_ctypes.pyi
@@ -22,6 +22,9 @@ RTLD_LOCAL: int
 if sys.version_info >= (3, 11):
     CTYPES_MAX_ARGCOUNT: int
 
+if sys.version_info >= (3, 12):
+    SIZEOF_TIME_T: int
+
 if sys.platform == "win32":
     # Description, Source, HelpFile, HelpContext, scode
     _COMError_Details: TypeAlias = tuple[str | None, str | None, str | None, int | None, int | None]
@@ -148,7 +151,11 @@ class Array(Generic[_CT], _CData):
     def _type_(self) -> type[_CT]: ...
     @_type_.setter
     def _type_(self, value: type[_CT]) -> None: ...
-    raw: bytes  # Note: only available if _CT == c_char
+    # Note: only available if _CT == c_char
+    @property
+    def raw(self) -> bytes: ...
+    @raw.setter
+    def raw(self, value: ReadableBuffer) -> None: ...
     value: Any  # Note: bytes if _CT == c_char, str if _CT == c_wchar, unavailable otherwise
     # TODO These methods cannot be annotated correctly at the moment.
     # All of these "Any"s stand for the array's element type, but it's not possible to use _CT
diff --git a/mypy/typeshed/stdlib/_socket.pyi b/mypy/typeshed/stdlib/_socket.pyi
index f7b0e6901bf4c..7a0ede62838c1 100644
--- a/mypy/typeshed/stdlib/_socket.pyi
+++ b/mypy/typeshed/stdlib/_socket.pyi
@@ -692,3 +692,28 @@ if sys.platform != "win32" or sys.version_info >= (3, 8):
     def if_nameindex() -> list[tuple[int, str]]: ...
     def if_nametoindex(__name: str) -> int: ...
     def if_indextoname(__index: int) -> str: ...
+
+if sys.version_info >= (3, 12):
+    IP_PKTINFO: int
+    IP_UNBLOCK_SOURCE: int
+    IP_BLOCK_SOURCE: int
+    IP_ADD_SOURCE_MEMBERSHIP: int
+    IP_DROP_SOURCE_MEMBERSHIP: int
+    if sys.platform == "win32":
+        AF_HYPERV: int
+        HV_PROTOCOL_RAW: int
+        HVSOCKET_CONNECT_TIMEOUT: int
+        HVSOCKET_CONNECT_TIMEOUT_MAX: int
+        HVSOCKET_CONNECTED_SUSPEND: int
+        HVSOCKET_ADDRESS_FLAG_PASSTHRU: int
+        HV_GUID_ZERO: str
+        HV_GUID_WILDCARD: str
+        HV_GUID_BROADCAST: str
+        HV_GUID_CHILDREN: str
+        HV_GUID_LOOPBACK: str
+        HV_GUID_PARENT: str
+    else:
+        ETHERTYPE_ARP: int
+        ETHERTYPE_IP: int
+        ETHERTYPE_IPV6: int
+        ETHERTYPE_VLAN: int
diff --git a/mypy/typeshed/stdlib/_thread.pyi b/mypy/typeshed/stdlib/_thread.pyi
index 152362edcaea9..dba8664fbf132 100644
--- a/mypy/typeshed/stdlib/_thread.pyi
+++ b/mypy/typeshed/stdlib/_thread.pyi
@@ -43,3 +43,6 @@ if sys.version_info >= (3, 8):
         @property
         def thread(self) -> Thread | None: ...
     _excepthook: Callable[[_ExceptHookArgs], Any]
+
+if sys.version_info >= (3, 12):
+    def daemon_threads_allowed() -> bool: ...
diff --git a/mypy/typeshed/stdlib/_winapi.pyi b/mypy/typeshed/stdlib/_winapi.pyi
index ca1e61f0f19f3..b51d844701ac4 100644
--- a/mypy/typeshed/stdlib/_winapi.pyi
+++ b/mypy/typeshed/stdlib/_winapi.pyi
@@ -137,6 +137,34 @@ if sys.platform == "win32":
         LCMAP_TRADITIONAL_CHINESE: int
         LCMAP_UPPERCASE: int
 
+    if sys.version_info >= (3, 12):
+        COPYFILE2_CALLBACK_CHUNK_STARTED: Literal[1]
+        COPYFILE2_CALLBACK_CHUNK_FINISHED: Literal[2]
+        COPYFILE2_CALLBACK_STREAM_STARTED: Literal[3]
+        COPYFILE2_CALLBACK_STREAM_FINISHED: Literal[4]
+        COPYFILE2_CALLBACK_POLL_CONTINUE: Literal[5]
+        COPYFILE2_CALLBACK_ERROR: Literal[6]
+
+        COPYFILE2_PROGRESS_CONTINUE: Literal[0]
+        COPYFILE2_PROGRESS_CANCEL: Literal[1]
+        COPYFILE2_PROGRESS_STOP: Literal[2]
+        COPYFILE2_PROGRESS_QUIET: Literal[3]
+        COPYFILE2_PROGRESS_PAUSE: Literal[4]
+
+        COPY_FILE_FAIL_IF_EXISTS: Literal[0x1]
+        COPY_FILE_RESTARTABLE: Literal[0x2]
+        COPY_FILE_OPEN_SOURCE_FOR_WRITE: Literal[0x4]
+        COPY_FILE_ALLOW_DECRYPTED_DESTINATION: Literal[0x8]
+        COPY_FILE_COPY_SYMLINK: Literal[0x800]
+        COPY_FILE_NO_BUFFERING: Literal[0x1000]
+        COPY_FILE_REQUEST_SECURITY_PRIVILEGES: Literal[0x2000]
+        COPY_FILE_RESUME_FROM_PAUSE: Literal[0x4000]
+        COPY_FILE_NO_OFFLOAD: Literal[0x40000]
+        COPY_FILE_REQUEST_COMPRESSED_TRAFFIC: Literal[0x10000000]
+
+        ERROR_ACCESS_DENIED: Literal[5]
+        ERROR_PRIVILEGE_NOT_HELD: Literal[1314]
+
     def CloseHandle(__handle: int) -> None: ...
     @overload
     def ConnectNamedPipe(handle: int, overlapped: Literal[True]) -> Overlapped: ...
@@ -224,3 +252,6 @@ if sys.platform == "win32":
         def GetOverlappedResult(self, __wait: bool) -> tuple[int, int]: ...
         def cancel(self) -> None: ...
         def getbuffer(self) -> bytes | None: ...
+
+    if sys.version_info >= (3, 12):
+        def CopyFile2(existing_file_name: str, new_file_name: str, flags: int, progress_routine: int | None = None) -> int: ...
diff --git a/mypy/typeshed/stdlib/argparse.pyi b/mypy/typeshed/stdlib/argparse.pyi
index c986b9cdb0820..e41048516dd9a 100644
--- a/mypy/typeshed/stdlib/argparse.pyi
+++ b/mypy/typeshed/stdlib/argparse.pyi
@@ -97,8 +97,16 @@ class _ActionsContainer:
         version: str = ...,
         **kwargs: Any,
     ) -> Action: ...
-    def add_argument_group(self, *args: Any, **kwargs: Any) -> _ArgumentGroup: ...
-    def add_mutually_exclusive_group(self, **kwargs: Any) -> _MutuallyExclusiveGroup: ...
+    def add_argument_group(
+        self,
+        title: str | None = None,
+        description: str | None = None,
+        *,
+        prefix_chars: str = ...,
+        argument_default: Any = ...,
+        conflict_handler: str = ...,
+    ) -> _ArgumentGroup: ...
+    def add_mutually_exclusive_group(self, *, required: bool = False) -> _MutuallyExclusiveGroup: ...
     def _add_action(self, action: _ActionT) -> _ActionT: ...
     def _remove_action(self, action: Action) -> None: ...
     def _add_container_actions(self, container: _ActionsContainer) -> None: ...
@@ -161,9 +169,9 @@ class ArgumentParser(_AttributeHolder, _ActionsContainer):
             add_help: bool = True,
             allow_abbrev: bool = True,
         ) -> None: ...
-    # Ignore errors about overlapping overloads
+
     @overload
-    def parse_args(self, args: Sequence[str] | None = None, namespace: None = None) -> Namespace: ...  # type: ignore[misc]
+    def parse_args(self, args: Sequence[str] | None = None, namespace: Namespace | None = None) -> Namespace: ...  # type: ignore[misc]
     @overload
     def parse_args(self, args: Sequence[str] | None, namespace: _N) -> _N: ...
     @overload
@@ -201,16 +209,27 @@ class ArgumentParser(_AttributeHolder, _ActionsContainer):
     def print_help(self, file: IO[str] | None = None) -> None: ...
     def format_usage(self) -> str: ...
     def format_help(self) -> str: ...
-    def parse_known_args(
-        self, args: Sequence[str] | None = None, namespace: Namespace | None = None
-    ) -> tuple[Namespace, list[str]]: ...
+    @overload
+    def parse_known_args(self, args: Sequence[str] | None = None, namespace: Namespace | None = None) -> tuple[Namespace, list[str]]: ...  # type: ignore[misc]
+    @overload
+    def parse_known_args(self, args: Sequence[str] | None, namespace: _N) -> tuple[_N, list[str]]: ...
+    @overload
+    def parse_known_args(self, *, namespace: _N) -> tuple[_N, list[str]]: ...
     def convert_arg_line_to_args(self, arg_line: str) -> list[str]: ...
     def exit(self, status: int = 0, message: str | None = None) -> NoReturn: ...
     def error(self, message: str) -> NoReturn: ...
-    def parse_intermixed_args(self, args: Sequence[str] | None = None, namespace: Namespace | None = None) -> Namespace: ...
-    def parse_known_intermixed_args(
-        self, args: Sequence[str] | None = None, namespace: Namespace | None = None
-    ) -> tuple[Namespace, list[str]]: ...
+    @overload
+    def parse_intermixed_args(self, args: Sequence[str] | None = None, namespace: Namespace | None = None) -> Namespace: ...  # type: ignore[misc]
+    @overload
+    def parse_intermixed_args(self, args: Sequence[str] | None, namespace: _N) -> _N: ...
+    @overload
+    def parse_intermixed_args(self, *, namespace: _N) -> _N: ...
+    @overload
+    def parse_known_intermixed_args(self, args: Sequence[str] | None = None, namespace: Namespace | None = None) -> tuple[Namespace, list[str]]: ...  # type: ignore[misc]
+    @overload
+    def parse_known_intermixed_args(self, args: Sequence[str] | None, namespace: _N) -> tuple[_N, list[str]]: ...
+    @overload
+    def parse_known_intermixed_args(self, *, namespace: _N) -> tuple[_N, list[str]]: ...
     # undocumented
     def _get_optional_actions(self) -> list[Action]: ...
     def _get_positional_actions(self) -> list[Action]: ...
@@ -350,7 +369,14 @@ class _ArgumentGroup(_ActionsContainer):
     title: str | None
     _group_actions: list[Action]
     def __init__(
-        self, container: _ActionsContainer, title: str | None = None, description: str | None = None, **kwargs: Any
+        self,
+        container: _ActionsContainer,
+        title: str | None = None,
+        description: str | None = None,
+        *,
+        prefix_chars: str = ...,
+        argument_default: Any = ...,
+        conflict_handler: str = ...,
     ) -> None: ...
 
 # undocumented
diff --git a/mypy/typeshed/stdlib/ast.pyi b/mypy/typeshed/stdlib/ast.pyi
index ea899e150f97f..3771381413405 100644
--- a/mypy/typeshed/stdlib/ast.pyi
+++ b/mypy/typeshed/stdlib/ast.pyi
@@ -3,7 +3,7 @@ import sys
 from _ast import *
 from _typeshed import ReadableBuffer, Unused
 from collections.abc import Iterator
-from typing import Any, TypeVar, overload
+from typing import Any, TypeVar as _TypeVar, overload
 from typing_extensions import Literal
 
 if sys.version_info >= (3, 8):
@@ -168,7 +168,7 @@ class NodeTransformer(NodeVisitor):
     #       The usual return type is AST | None, but Iterable[AST]
     #       is also allowed in some cases -- this needs to be mapped.
 
-_T = TypeVar("_T", bound=AST)
+_T = _TypeVar("_T", bound=AST)
 
 if sys.version_info >= (3, 8):
     @overload
diff --git a/mypy/typeshed/stdlib/builtins.pyi b/mypy/typeshed/stdlib/builtins.pyi
index 0676aba1277ed..b3871776128ad 100644
--- a/mypy/typeshed/stdlib/builtins.pyi
+++ b/mypy/typeshed/stdlib/builtins.pyi
@@ -53,7 +53,18 @@ from typing import (  # noqa: Y022
     overload,
     type_check_only,
 )
-from typing_extensions import Concatenate, Literal, ParamSpec, Self, SupportsIndex, TypeAlias, TypeGuard, final
+from typing_extensions import (  # type: ignore
+    Concatenate,
+    Literal,
+    LiteralString,
+    ParamSpec,
+    Self,
+    SupportsIndex,
+    TypeAlias,
+    TypeGuard,
+    TypeVarTuple,
+    final,
+)
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -187,6 +198,8 @@ class type:
     if sys.version_info >= (3, 10):
         def __or__(self, __value: Any) -> types.UnionType: ...
         def __ror__(self, __value: Any) -> types.UnionType: ...
+    if sys.version_info >= (3, 12):
+        __type_params__: tuple[TypeVar | ParamSpec | TypeVarTuple, ...]
 
 class super:
     @overload
@@ -244,6 +257,9 @@ class int:
             signed: bool = False,
         ) -> Self: ...
 
+    if sys.version_info >= (3, 12):
+        def is_integer(self) -> Literal[True]: ...
+
     def __add__(self, __value: int) -> int: ...
     def __sub__(self, __value: int) -> int: ...
     def __mul__(self, __value: int) -> int: ...
@@ -417,8 +433,17 @@ class str(Sequence[str]):
     def __new__(cls, object: object = ...) -> Self: ...
     @overload
     def __new__(cls, object: ReadableBuffer, encoding: str = ..., errors: str = ...) -> Self: ...
+    @overload
+    def capitalize(self: LiteralString) -> LiteralString: ...
+    @overload
     def capitalize(self) -> str: ...  # type: ignore[misc]
+    @overload
+    def casefold(self: LiteralString) -> LiteralString: ...
+    @overload
     def casefold(self) -> str: ...  # type: ignore[misc]
+    @overload
+    def center(self: LiteralString, __width: SupportsIndex, __fillchar: LiteralString = " ") -> LiteralString: ...
+    @overload
     def center(self, __width: SupportsIndex, __fillchar: str = " ") -> str: ...  # type: ignore[misc]
     def count(self, x: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
     def encode(self, encoding: str = "utf-8", errors: str = "strict") -> bytes: ...
@@ -426,12 +451,21 @@ class str(Sequence[str]):
         self, __suffix: str | tuple[str, ...], __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...
     ) -> bool: ...
     if sys.version_info >= (3, 8):
+        @overload
+        def expandtabs(self: LiteralString, tabsize: SupportsIndex = 8) -> LiteralString: ...
+        @overload
         def expandtabs(self, tabsize: SupportsIndex = 8) -> str: ...  # type: ignore[misc]
     else:
+        @overload
+        def expandtabs(self: LiteralString, tabsize: int = 8) -> LiteralString: ...
+        @overload
         def expandtabs(self, tabsize: int = 8) -> str: ...  # type: ignore[misc]
 
     def find(self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
-    def format(self, *args: object, **kwargs: object) -> str: ...
+    @overload
+    def format(self: LiteralString, *args: LiteralString, **kwargs: LiteralString) -> LiteralString: ...
+    @overload
+    def format(self, *args: object, **kwargs: object) -> str: ...  # type: ignore
     def format_map(self, map: _FormatMapMapping) -> str: ...
     def index(self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
     def isalnum(self) -> bool: ...
@@ -446,32 +480,91 @@ class str(Sequence[str]):
     def isspace(self) -> bool: ...
     def istitle(self) -> bool: ...
     def isupper(self) -> bool: ...
+    @overload
+    def join(self: LiteralString, __iterable: Iterable[LiteralString]) -> LiteralString: ...
+    @overload
     def join(self, __iterable: Iterable[str]) -> str: ...  # type: ignore[misc]
+    @overload
+    def ljust(self: LiteralString, __width: SupportsIndex, __fillchar: LiteralString = " ") -> LiteralString: ...
+    @overload
     def ljust(self, __width: SupportsIndex, __fillchar: str = " ") -> str: ...  # type: ignore[misc]
+    @overload
+    def lower(self: LiteralString) -> LiteralString: ...
+    @overload
     def lower(self) -> str: ...  # type: ignore[misc]
+    @overload
+    def lstrip(self: LiteralString, __chars: LiteralString | None = None) -> LiteralString: ...
+    @overload
     def lstrip(self, __chars: str | None = None) -> str: ...  # type: ignore[misc]
+    @overload
+    def partition(self: LiteralString, __sep: LiteralString) -> tuple[LiteralString, LiteralString, LiteralString]: ...
+    @overload
     def partition(self, __sep: str) -> tuple[str, str, str]: ...  # type: ignore[misc]
+    @overload
+    def replace(
+        self: LiteralString, __old: LiteralString, __new: LiteralString, __count: SupportsIndex = -1
+    ) -> LiteralString: ...
+    @overload
     def replace(self, __old: str, __new: str, __count: SupportsIndex = -1) -> str: ...  # type: ignore[misc]
     if sys.version_info >= (3, 9):
+        @overload
+        def removeprefix(self: LiteralString, __prefix: LiteralString) -> LiteralString: ...
+        @overload
         def removeprefix(self, __prefix: str) -> str: ...  # type: ignore[misc]
+        @overload
+        def removesuffix(self: LiteralString, __suffix: LiteralString) -> LiteralString: ...
+        @overload
         def removesuffix(self, __suffix: str) -> str: ...  # type: ignore[misc]
 
     def rfind(self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
     def rindex(self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
+    @overload
+    def rjust(self: LiteralString, __width: SupportsIndex, __fillchar: LiteralString = " ") -> LiteralString: ...
+    @overload
     def rjust(self, __width: SupportsIndex, __fillchar: str = " ") -> str: ...  # type: ignore[misc]
+    @overload
+    def rpartition(self: LiteralString, __sep: LiteralString) -> tuple[LiteralString, LiteralString, LiteralString]: ...
+    @overload
     def rpartition(self, __sep: str) -> tuple[str, str, str]: ...  # type: ignore[misc]
+    @overload
+    def rsplit(self: LiteralString, sep: LiteralString | None = None, maxsplit: SupportsIndex = -1) -> list[LiteralString]: ...
+    @overload
     def rsplit(self, sep: str | None = None, maxsplit: SupportsIndex = -1) -> list[str]: ...  # type: ignore[misc]
+    @overload
+    def rstrip(self: LiteralString, __chars: LiteralString | None = None) -> LiteralString: ...
+    @overload
     def rstrip(self, __chars: str | None = None) -> str: ...  # type: ignore[misc]
+    @overload
+    def split(self: LiteralString, sep: LiteralString | None = None, maxsplit: SupportsIndex = -1) -> list[LiteralString]: ...
+    @overload
     def split(self, sep: str | None = None, maxsplit: SupportsIndex = -1) -> list[str]: ...  # type: ignore[misc]
+    @overload
+    def splitlines(self: LiteralString, keepends: bool = False) -> list[LiteralString]: ...
+    @overload
     def splitlines(self, keepends: bool = False) -> list[str]: ...  # type: ignore[misc]
     def startswith(
         self, __prefix: str | tuple[str, ...], __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...
     ) -> bool: ...
+    @overload
+    def strip(self: LiteralString, __chars: LiteralString | None = None) -> LiteralString: ...
+    @overload
     def strip(self, __chars: str | None = None) -> str: ...  # type: ignore[misc]
+    @overload
+    def swapcase(self: LiteralString) -> LiteralString: ...
+    @overload
     def swapcase(self) -> str: ...  # type: ignore[misc]
+    @overload
+    def title(self: LiteralString) -> LiteralString: ...
+    @overload
     def title(self) -> str: ...  # type: ignore[misc]
     def translate(self, __table: _TranslateTable) -> str: ...
+    @overload
+    def upper(self: LiteralString) -> LiteralString: ...
+    @overload
     def upper(self) -> str: ...  # type: ignore[misc]
+    @overload
+    def zfill(self: LiteralString, __width: SupportsIndex) -> LiteralString: ...
+    @overload
     def zfill(self, __width: SupportsIndex) -> str: ...  # type: ignore[misc]
     @staticmethod
     @overload
@@ -482,6 +575,9 @@ class str(Sequence[str]):
     @staticmethod
     @overload
     def maketrans(__x: str, __y: str, __z: str) -> dict[int, int | None]: ...
+    @overload
+    def __add__(self: LiteralString, __value: LiteralString) -> LiteralString: ...
+    @overload
     def __add__(self, __value: str) -> str: ...  # type: ignore[misc]
     # Incompatible with Sequence.__contains__
     def __contains__(self, __key: str) -> bool: ...  # type: ignore[override]
@@ -489,13 +585,25 @@ class str(Sequence[str]):
     def __ge__(self, __value: str) -> bool: ...
     def __getitem__(self, __key: SupportsIndex | slice) -> str: ...
     def __gt__(self, __value: str) -> bool: ...
+    @overload
+    def __iter__(self: LiteralString) -> Iterator[LiteralString]: ...
+    @overload
     def __iter__(self) -> Iterator[str]: ...  # type: ignore[misc]
     def __le__(self, __value: str) -> bool: ...
     def __len__(self) -> int: ...
     def __lt__(self, __value: str) -> bool: ...
-    def __mod__(self, __value: Any) -> str: ...
+    @overload
+    def __mod__(self: LiteralString, __value: LiteralString | tuple[LiteralString, ...]) -> LiteralString: ...
+    @overload
+    def __mod__(self, __value: Any) -> str: ...  # type: ignore
+    @overload
+    def __mul__(self: LiteralString, __value: SupportsIndex) -> LiteralString: ...
+    @overload
     def __mul__(self, __value: SupportsIndex) -> str: ...  # type: ignore[misc]
     def __ne__(self, __value: object) -> bool: ...
+    @overload
+    def __rmul__(self: LiteralString, __value: SupportsIndex) -> LiteralString: ...
+    @overload
     def __rmul__(self, __value: SupportsIndex) -> str: ...  # type: ignore[misc]
     def __getnewargs__(self) -> tuple[str]: ...
 
@@ -874,6 +982,8 @@ class function:
     if sys.version_info >= (3, 10):
         @property
         def __builtins__(self) -> dict[str, Any]: ...
+    if sys.version_info >= (3, 12):
+        __type_params__: tuple[TypeVar | ParamSpec | TypeVarTuple, ...]
 
     __module__: str
     # mypy uses `builtins.function.__get__` to represent methods, properties, and getset_descriptors so we type the return as Any.
@@ -1648,11 +1758,11 @@ _SupportsSumNoDefaultT = TypeVar("_SupportsSumNoDefaultT", bound=_SupportsSumWit
 # Instead, we special-case the most common examples of this: bool and literal integers.
 if sys.version_info >= (3, 8):
     @overload
-    def sum(__iterable: Iterable[bool], start: int = 0) -> int: ...  # type: ignore[misc]
+    def sum(__iterable: Iterable[bool | _LiteralInteger], start: int = 0) -> int: ...  # type: ignore[misc]
 
 else:
     @overload
-    def sum(__iterable: Iterable[bool], __start: int = 0) -> int: ...  # type: ignore[misc]
+    def sum(__iterable: Iterable[bool | _LiteralInteger], __start: int = 0) -> int: ...  # type: ignore[misc]
 
 @overload
 def sum(__iterable: Iterable[_SupportsSumNoDefaultT]) -> _SupportsSumNoDefaultT | Literal[0]: ...
@@ -1826,6 +1936,8 @@ class ImportError(Exception):
     name: str | None
     path: str | None
     msg: str  # undocumented
+    if sys.version_info >= (3, 12):
+        name_from: str | None  # undocumented
 
 class LookupError(Exception): ...
 class MemoryError(Exception): ...
diff --git a/mypy/typeshed/stdlib/calendar.pyi b/mypy/typeshed/stdlib/calendar.pyi
index 255a12d3348ae..3f881393e99f7 100644
--- a/mypy/typeshed/stdlib/calendar.pyi
+++ b/mypy/typeshed/stdlib/calendar.pyi
@@ -1,4 +1,5 @@
 import datetime
+import enum
 import sys
 from _typeshed import Unused
 from collections.abc import Iterable, Sequence
@@ -35,6 +36,23 @@ __all__ = [
 
 if sys.version_info >= (3, 10):
     __all__ += ["FRIDAY", "MONDAY", "SATURDAY", "SUNDAY", "THURSDAY", "TUESDAY", "WEDNESDAY"]
+if sys.version_info >= (3, 12):
+    __all__ += [
+        "Day",
+        "Month",
+        "JANUARY",
+        "FEBRUARY",
+        "MARCH",
+        "APRIL",
+        "MAY",
+        "JUNE",
+        "JULY",
+        "AUGUST",
+        "SEPTEMBER",
+        "OCTOBER",
+        "NOVEMBER",
+        "DECEMBER",
+    ]
 
 _LocaleType: TypeAlias = tuple[str | None, str | None]
 
@@ -134,12 +152,55 @@ day_abbr: Sequence[str]
 month_name: Sequence[str]
 month_abbr: Sequence[str]
 
-MONDAY: Literal[0]
-TUESDAY: Literal[1]
-WEDNESDAY: Literal[2]
-THURSDAY: Literal[3]
-FRIDAY: Literal[4]
-SATURDAY: Literal[5]
-SUNDAY: Literal[6]
+if sys.version_info >= (3, 12):
+    class Month(enum.IntEnum):
+        JANUARY: Literal[1]
+        FEBRUARY: Literal[2]
+        MARCH: Literal[3]
+        APRIL: Literal[4]
+        MAY: Literal[5]
+        JUNE: Literal[6]
+        JULY: Literal[7]
+        AUGUST: Literal[8]
+        SEPTEMBER: Literal[9]
+        OCTOBER: Literal[10]
+        NOVEMBER: Literal[11]
+        DECEMBER: Literal[12]
+    JANUARY = Month.JANUARY
+    FEBRUARY = Month.FEBRUARY
+    MARCH = Month.MARCH
+    APRIL = Month.APRIL
+    MAY = Month.MAY
+    JUNE = Month.JUNE
+    JULY = Month.JULY
+    AUGUST = Month.AUGUST
+    SEPTEMBER = Month.SEPTEMBER
+    OCTOBER = Month.OCTOBER
+    NOVEMBER = Month.NOVEMBER
+    DECEMBER = Month.DECEMBER
+
+    class Day(enum.IntEnum):
+        MONDAY: Literal[0]
+        TUESDAY: Literal[1]
+        WEDNESDAY: Literal[2]
+        THURSDAY: Literal[3]
+        FRIDAY: Literal[4]
+        SATURDAY: Literal[5]
+        SUNDAY: Literal[6]
+    MONDAY = Day.MONDAY
+    TUESDAY = Day.TUESDAY
+    WEDNESDAY = Day.WEDNESDAY
+    THURSDAY = Day.THURSDAY
+    FRIDAY = Day.FRIDAY
+    SATURDAY = Day.SATURDAY
+    SUNDAY = Day.SUNDAY
+else:
+    MONDAY: Literal[0]
+    TUESDAY: Literal[1]
+    WEDNESDAY: Literal[2]
+    THURSDAY: Literal[3]
+    FRIDAY: Literal[4]
+    SATURDAY: Literal[5]
+    SUNDAY: Literal[6]
 
 EPOCH: Literal[1970]
diff --git a/mypy/typeshed/stdlib/csv.pyi b/mypy/typeshed/stdlib/csv.pyi
index 59f2e7a3c96bf..139ba7af22089 100644
--- a/mypy/typeshed/stdlib/csv.pyi
+++ b/mypy/typeshed/stdlib/csv.pyi
@@ -21,6 +21,9 @@ from _csv import (
     unregister_dialect as unregister_dialect,
     writer as writer,
 )
+
+if sys.version_info >= (3, 12):
+    from _csv import QUOTE_STRINGS as QUOTE_STRINGS, QUOTE_NOTNULL as QUOTE_NOTNULL
 from _typeshed import SupportsWrite
 from collections.abc import Collection, Iterable, Iterator, Mapping, Sequence
 from typing import Any, Generic, TypeVar, overload
@@ -57,6 +60,8 @@ __all__ = [
     "DictWriter",
     "unix_dialect",
 ]
+if sys.version_info >= (3, 12):
+    __all__ += ["QUOTE_STRINGS", "QUOTE_NOTNULL"]
 
 _T = TypeVar("_T")
 
diff --git a/mypy/typeshed/stdlib/ctypes/__init__.pyi b/mypy/typeshed/stdlib/ctypes/__init__.pyi
index 7a185a5b523e6..b14fb93c81636 100644
--- a/mypy/typeshed/stdlib/ctypes/__init__.pyi
+++ b/mypy/typeshed/stdlib/ctypes/__init__.pyi
@@ -181,6 +181,9 @@ class c_bool(_SimpleCData[bool]):
 if sys.platform == "win32":
     class HRESULT(_SimpleCData[int]): ...  # TODO undocumented
 
+if sys.version_info >= (3, 12):
+    c_time_t: type[c_int32 | c_int64]
+
 class py_object(_CanCastTo, _SimpleCData[_T]): ...
 class BigEndianStructure(Structure): ...
 class LittleEndianStructure(Structure): ...
diff --git a/mypy/typeshed/stdlib/dis.pyi b/mypy/typeshed/stdlib/dis.pyi
index d153771e676bc..ab101a517a6f3 100644
--- a/mypy/typeshed/stdlib/dis.pyi
+++ b/mypy/typeshed/stdlib/dis.pyi
@@ -29,9 +29,12 @@ __all__ = [
     "opmap",
     "HAVE_ARGUMENT",
     "EXTENDED_ARG",
-    "hasnargs",
     "stack_effect",
 ]
+if sys.version_info >= (3, 12):
+    __all__ += ["hasarg", "hasexc"]
+else:
+    __all__ += ["hasnargs"]
 
 # Strictly this should not have to include Callable, but mypy doesn't use FunctionType
 # for functions (python/mypy#3171)
diff --git a/mypy/typeshed/stdlib/distutils/__init__.pyi b/mypy/typeshed/stdlib/distutils/__init__.pyi
index e69de29bb2d1d..328a5b7834419 100644
--- a/mypy/typeshed/stdlib/distutils/__init__.pyi
+++ b/mypy/typeshed/stdlib/distutils/__init__.pyi
@@ -0,0 +1,5 @@
+# Attempts to improve these stubs are probably not the best use of time:
+# - distutils is deleted in Python 3.12 and newer
+# - Most users already do not use stdlib distutils, due to setuptools monkeypatching
+# - We have very little quality assurance on these stubs, since due to the two above issues
+#   we allowlist all distutils errors in stubtest.
diff --git a/mypy/typeshed/stdlib/email/generator.pyi b/mypy/typeshed/stdlib/email/generator.pyi
index 8362dd9c4ff6f..faa6551fc925e 100644
--- a/mypy/typeshed/stdlib/email/generator.pyi
+++ b/mypy/typeshed/stdlib/email/generator.pyi
@@ -1,11 +1,12 @@
 from _typeshed import SupportsWrite
 from email.message import Message
 from email.policy import Policy
+from typing_extensions import Self
 
 __all__ = ["Generator", "DecodedGenerator", "BytesGenerator"]
 
 class Generator:
-    def clone(self, fp: SupportsWrite[str]) -> Generator: ...
+    def clone(self, fp: SupportsWrite[str]) -> Self: ...
     def write(self, s: str) -> None: ...
     def __init__(
         self,
@@ -17,9 +18,7 @@ class Generator:
     ) -> None: ...
     def flatten(self, msg: Message, unixfrom: bool = False, linesep: str | None = None) -> None: ...
 
-class BytesGenerator:
-    def clone(self, fp: SupportsWrite[bytes]) -> BytesGenerator: ...
-    def write(self, s: str) -> None: ...
+class BytesGenerator(Generator):
     def __init__(
         self,
         outfp: SupportsWrite[bytes],
@@ -28,7 +27,6 @@ class BytesGenerator:
         *,
         policy: Policy | None = None,
     ) -> None: ...
-    def flatten(self, msg: Message, unixfrom: bool = False, linesep: str | None = None) -> None: ...
 
 class DecodedGenerator(Generator):
     def __init__(
diff --git a/mypy/typeshed/stdlib/email/policy.pyi b/mypy/typeshed/stdlib/email/policy.pyi
index 4df3c1e48b07c..dc7f18489bfa0 100644
--- a/mypy/typeshed/stdlib/email/policy.pyi
+++ b/mypy/typeshed/stdlib/email/policy.pyi
@@ -5,6 +5,7 @@ from email.errors import MessageDefect
 from email.header import Header
 from email.message import Message
 from typing import Any
+from typing_extensions import Self
 
 __all__ = ["Compat32", "compat32", "Policy", "EmailPolicy", "default", "strict", "SMTP", "HTTP"]
 
@@ -25,7 +26,7 @@ class Policy(metaclass=ABCMeta):
         mangle_from_: bool = ...,
         message_factory: Callable[[Policy], Message] | None = ...,
     ) -> None: ...
-    def clone(self, **kw: Any) -> Policy: ...
+    def clone(self, **kw: Any) -> Self: ...
     def handle_defect(self, obj: Message, defect: MessageDefect) -> None: ...
     def register_defect(self, obj: Message, defect: MessageDefect) -> None: ...
     def header_max_count(self, name: str) -> int | None: ...
diff --git a/mypy/typeshed/stdlib/fcntl.pyi b/mypy/typeshed/stdlib/fcntl.pyi
index 01443083f48de..6aec7515f330b 100644
--- a/mypy/typeshed/stdlib/fcntl.pyi
+++ b/mypy/typeshed/stdlib/fcntl.pyi
@@ -20,6 +20,9 @@ if sys.platform != "win32":
     F_SETOWN: int
     F_UNLCK: int
     F_WRLCK: int
+
+    F_GETLEASE: int
+    F_SETLEASE: int
     if sys.platform == "darwin":
         F_FULLFSYNC: int
         F_NOCACHE: int
@@ -30,11 +33,9 @@ if sys.platform != "win32":
         F_SETSIG: int
         F_SHLCK: int
         F_SETLK64: int
-        F_SETLEASE: int
         F_GETSIG: int
         F_NOTIFY: int
         F_EXLCK: int
-        F_GETLEASE: int
         F_GETLK64: int
         if sys.version_info >= (3, 8):
             F_ADD_SEALS: int
diff --git a/mypy/typeshed/stdlib/ftplib.pyi b/mypy/typeshed/stdlib/ftplib.pyi
index 36a213d486803..f24d14fbf2b68 100644
--- a/mypy/typeshed/stdlib/ftplib.pyi
+++ b/mypy/typeshed/stdlib/ftplib.pyi
@@ -118,7 +118,20 @@ class FTP:
     def close(self) -> None: ...
 
 class FTP_TLS(FTP):
-    if sys.version_info >= (3, 9):
+    if sys.version_info >= (3, 12):
+        def __init__(
+            self,
+            host: str = "",
+            user: str = "",
+            passwd: str = "",
+            acct: str = "",
+            *,
+            context: SSLContext | None = None,
+            timeout: float = ...,
+            source_address: tuple[str, int] | None = None,
+            encoding: str = "utf-8",
+        ) -> None: ...
+    elif sys.version_info >= (3, 9):
         def __init__(
             self,
             host: str = "",
diff --git a/mypy/typeshed/stdlib/functools.pyi b/mypy/typeshed/stdlib/functools.pyi
index d01fd8ce55cbd..8adc3d82292e2 100644
--- a/mypy/typeshed/stdlib/functools.pyi
+++ b/mypy/typeshed/stdlib/functools.pyi
@@ -1,9 +1,9 @@
 import sys
 import types
-from _typeshed import IdentityFunction, SupportsAllComparisons, SupportsItems
+from _typeshed import SupportsAllComparisons, SupportsItems
 from collections.abc import Callable, Hashable, Iterable, Sequence, Sized
 from typing import Any, Generic, NamedTuple, TypeVar, overload
-from typing_extensions import Literal, Self, TypeAlias, TypedDict, final
+from typing_extensions import Literal, ParamSpec, Self, TypeAlias, TypedDict, final
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -28,10 +28,12 @@ if sys.version_info >= (3, 8):
 if sys.version_info >= (3, 9):
     __all__ += ["cache"]
 
-_AnyCallable: TypeAlias = Callable[..., object]
-
 _T = TypeVar("_T")
 _S = TypeVar("_S")
+_PWrapped = ParamSpec("_PWrapped")
+_RWrapped = TypeVar("_RWrapped")
+_PWrapper = ParamSpec("_PWrapper")
+_RWapper = TypeVar("_RWapper")
 
 @overload
 def reduce(function: Callable[[_T, _S], _T], sequence: Iterable[_S], initial: _T) -> _T: ...
@@ -70,22 +72,57 @@ if sys.version_info >= (3, 8):
 else:
     def lru_cache(maxsize: int | None = 128, typed: bool = False) -> Callable[[Callable[..., _T]], _lru_cache_wrapper[_T]]: ...
 
-WRAPPER_ASSIGNMENTS: tuple[
-    Literal["__module__"], Literal["__name__"], Literal["__qualname__"], Literal["__doc__"], Literal["__annotations__"]
-]
+if sys.version_info >= (3, 12):
+    WRAPPER_ASSIGNMENTS: tuple[
+        Literal["__module__"],
+        Literal["__name__"],
+        Literal["__qualname__"],
+        Literal["__doc__"],
+        Literal["__annotations__"],
+        Literal["__type_params__"],
+    ]
+else:
+    WRAPPER_ASSIGNMENTS: tuple[
+        Literal["__module__"], Literal["__name__"], Literal["__qualname__"], Literal["__doc__"], Literal["__annotations__"]
+    ]
 WRAPPER_UPDATES: tuple[Literal["__dict__"]]
 
-def update_wrapper(
-    wrapper: _T,
-    wrapped: _AnyCallable,
-    assigned: Sequence[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__"),
-    updated: Sequence[str] = ("__dict__",),
-) -> _T: ...
-def wraps(
-    wrapped: _AnyCallable,
-    assigned: Sequence[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__"),
-    updated: Sequence[str] = ("__dict__",),
-) -> IdentityFunction: ...
+class _Wrapped(Generic[_PWrapped, _RWrapped, _PWrapper, _RWapper]):
+    __wrapped__: Callable[_PWrapped, _RWrapped]
+    def __call__(self, *args: _PWrapper.args, **kwargs: _PWrapper.kwargs) -> _RWapper: ...
+    # as with ``Callable``, we'll assume that these attributes exist
+    __name__: str
+    __qualname__: str
+
+class _Wrapper(Generic[_PWrapped, _RWrapped]):
+    def __call__(self, f: Callable[_PWrapper, _RWapper]) -> _Wrapped[_PWrapped, _RWrapped, _PWrapper, _RWapper]: ...
+
+if sys.version_info >= (3, 12):
+    def update_wrapper(
+        wrapper: Callable[_PWrapper, _RWapper],
+        wrapped: Callable[_PWrapped, _RWrapped],
+        assigned: Sequence[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__", "__type_params__"),
+        updated: Sequence[str] = ("__dict__",),
+    ) -> _Wrapped[_PWrapped, _RWrapped, _PWrapper, _RWapper]: ...
+    def wraps(
+        wrapped: Callable[_PWrapped, _RWrapped],
+        assigned: Sequence[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__", "__type_params__"),
+        updated: Sequence[str] = ("__dict__",),
+    ) -> _Wrapper[_PWrapped, _RWrapped]: ...
+
+else:
+    def update_wrapper(
+        wrapper: Callable[_PWrapper, _RWapper],
+        wrapped: Callable[_PWrapped, _RWrapped],
+        assigned: Sequence[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__"),
+        updated: Sequence[str] = ("__dict__",),
+    ) -> _Wrapped[_PWrapped, _RWrapped, _PWrapper, _RWapper]: ...
+    def wraps(
+        wrapped: Callable[_PWrapped, _RWrapped],
+        assigned: Sequence[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__"),
+        updated: Sequence[str] = ("__dict__",),
+    ) -> _Wrapper[_PWrapped, _RWrapped]: ...
+
 def total_ordering(cls: type[_T]) -> type[_T]: ...
 def cmp_to_key(mycmp: Callable[[_T, _T], int]) -> Callable[[_T], SupportsAllComparisons]: ...
 
diff --git a/mypy/typeshed/stdlib/http/__init__.pyi b/mypy/typeshed/stdlib/http/__init__.pyi
index d4b44f2eb99b1..4310c79b92690 100644
--- a/mypy/typeshed/stdlib/http/__init__.pyi
+++ b/mypy/typeshed/stdlib/http/__init__.pyi
@@ -79,6 +79,17 @@ class HTTPStatus(IntEnum):
         EARLY_HINTS: Literal[103]
         IM_A_TEAPOT: Literal[418]
         TOO_EARLY: Literal[425]
+    if sys.version_info >= (3, 12):
+        @property
+        def is_informational(self) -> bool: ...
+        @property
+        def is_success(self) -> bool: ...
+        @property
+        def is_redirection(self) -> bool: ...
+        @property
+        def is_client_error(self) -> bool: ...
+        @property
+        def is_server_error(self) -> bool: ...
 
 if sys.version_info >= (3, 11):
     class HTTPMethod(StrEnum):
diff --git a/mypy/typeshed/stdlib/locale.pyi b/mypy/typeshed/stdlib/locale.pyi
index c6cc7cacfb1dd..3753700ea8890 100644
--- a/mypy/typeshed/stdlib/locale.pyi
+++ b/mypy/typeshed/stdlib/locale.pyi
@@ -15,7 +15,6 @@ __all__ = [
     "str",
     "atof",
     "atoi",
-    "format",
     "format_string",
     "currency",
     "normalize",
@@ -32,6 +31,9 @@ __all__ = [
 if sys.version_info >= (3, 11):
     __all__ += ["getencoding"]
 
+if sys.version_info < (3, 12):
+    __all__ += ["format"]
+
 # This module defines a function "str()", which is why "str" can't be used
 # as a type annotation or type alias.
 from builtins import str as _str
@@ -123,7 +125,12 @@ def normalize(localename: _str) -> _str: ...
 def resetlocale(category: int = ...) -> None: ...
 def strcoll(__os1: _str, __os2: _str) -> int: ...
 def strxfrm(__string: _str) -> _str: ...
-def format(percent: _str, value: float | Decimal, grouping: bool = False, monetary: bool = False, *additional: Any) -> _str: ...
+
+if sys.version_info < (3, 12):
+    def format(
+        percent: _str, value: float | Decimal, grouping: bool = False, monetary: bool = False, *additional: Any
+    ) -> _str: ...
+
 def format_string(f: _str, val: Any, grouping: bool = False, monetary: bool = False) -> _str: ...
 def currency(val: float | Decimal, symbol: bool = True, grouping: bool = False, international: bool = False) -> _str: ...
 def delocalize(string: _str) -> _str: ...
diff --git a/mypy/typeshed/stdlib/multiprocessing/connection.pyi b/mypy/typeshed/stdlib/multiprocessing/connection.pyi
index d034373712e05..28696fe6a3a38 100644
--- a/mypy/typeshed/stdlib/multiprocessing/connection.pyi
+++ b/mypy/typeshed/stdlib/multiprocessing/connection.pyi
@@ -52,7 +52,12 @@ class Listener:
         self, exc_type: type[BaseException] | None, exc_value: BaseException | None, exc_tb: types.TracebackType | None
     ) -> None: ...
 
-def deliver_challenge(connection: Connection, authkey: bytes) -> None: ...
+if sys.version_info >= (3, 12):
+    def deliver_challenge(connection: Connection, authkey: bytes, digest_name: str = "sha256") -> None: ...
+
+else:
+    def deliver_challenge(connection: Connection, authkey: bytes) -> None: ...
+
 def answer_challenge(connection: Connection, authkey: bytes) -> None: ...
 def wait(
     object_list: Iterable[Connection | socket.socket | int], timeout: float | None = None
diff --git a/mypy/typeshed/stdlib/multiprocessing/queues.pyi b/mypy/typeshed/stdlib/multiprocessing/queues.pyi
index a26ab71732320..8e72d15f25f63 100644
--- a/mypy/typeshed/stdlib/multiprocessing/queues.pyi
+++ b/mypy/typeshed/stdlib/multiprocessing/queues.pyi
@@ -22,6 +22,8 @@ class Queue(Generic[_T]):
     def close(self) -> None: ...
     def join_thread(self) -> None: ...
     def cancel_join_thread(self) -> None: ...
+    if sys.version_info >= (3, 12):
+        def __class_getitem__(cls, __item: Any) -> GenericAlias: ...
 
 class JoinableQueue(Queue[_T]):
     def task_done(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/opcode.pyi b/mypy/typeshed/stdlib/opcode.pyi
index 1232454e71ea6..f852489ffacfd 100644
--- a/mypy/typeshed/stdlib/opcode.pyi
+++ b/mypy/typeshed/stdlib/opcode.pyi
@@ -14,9 +14,12 @@ __all__ = [
     "opmap",
     "HAVE_ARGUMENT",
     "EXTENDED_ARG",
-    "hasnargs",
     "stack_effect",
 ]
+if sys.version_info >= (3, 12):
+    __all__ += ["hasarg", "hasexc"]
+else:
+    __all__ += ["hasnargs"]
 
 if sys.version_info >= (3, 9):
     cmp_op: tuple[Literal["<"], Literal["<="], Literal["=="], Literal["!="], Literal[">"], Literal[">="]]
@@ -42,6 +45,11 @@ hasjabs: list[int]
 haslocal: list[int]
 hascompare: list[int]
 hasfree: list[int]
+if sys.version_info >= (3, 12):
+    hasarg: list[int]
+    hasexc: list[int]
+else:
+    hasnargs: list[int]
 opname: list[str]
 
 opmap: dict[str, int]
@@ -53,5 +61,3 @@ if sys.version_info >= (3, 8):
 
 else:
     def stack_effect(__opcode: int, __oparg: int | None = None) -> int: ...
-
-hasnargs: list[int]
diff --git a/mypy/typeshed/stdlib/pathlib.pyi b/mypy/typeshed/stdlib/pathlib.pyi
index 7aec66b584e37..3c2ae0fe7ab1a 100644
--- a/mypy/typeshed/stdlib/pathlib.pyi
+++ b/mypy/typeshed/stdlib/pathlib.pyi
@@ -55,7 +55,11 @@ class PurePath(PathLike[str]):
     if sys.version_info >= (3, 9):
         def is_relative_to(self, *other: StrPath) -> bool: ...
 
-    def match(self, path_pattern: str) -> bool: ...
+    if sys.version_info >= (3, 12):
+        def match(self, path_pattern: str, *, case_sensitive: bool | None = None) -> bool: ...
+    else:
+        def match(self, path_pattern: str) -> bool: ...
+
     def relative_to(self, *other: StrPath) -> Self: ...
     def with_name(self, name: str) -> Self: ...
     if sys.version_info >= (3, 9):
@@ -70,6 +74,9 @@ class PurePath(PathLike[str]):
     if sys.version_info >= (3, 9) and sys.version_info < (3, 11):
         def __class_getitem__(cls, type: Any) -> GenericAlias: ...
 
+    if sys.version_info >= (3, 12):
+        def with_segments(self, *args: StrPath) -> Self: ...
+
 class PurePosixPath(PurePath): ...
 class PureWindowsPath(PurePath): ...
 
@@ -86,8 +93,15 @@ class Path(PurePath):
         def stat(self) -> stat_result: ...
         def chmod(self, mode: int) -> None: ...
 
-    def exists(self) -> bool: ...
-    def glob(self, pattern: str) -> Generator[Self, None, None]: ...
+    if sys.version_info >= (3, 12):
+        def exists(self, *, follow_symlinks: bool = True) -> bool: ...
+        def glob(self, pattern: str, *, case_sensitive: bool | None = None) -> Generator[Self, None, None]: ...
+        def rglob(self, pattern: str, *, case_sensitive: bool | None = None) -> Generator[Self, None, None]: ...
+    else:
+        def exists(self) -> bool: ...
+        def glob(self, pattern: str) -> Generator[Self, None, None]: ...
+        def rglob(self, pattern: str) -> Generator[Self, None, None]: ...
+
     def is_dir(self) -> bool: ...
     def is_file(self) -> bool: ...
     def is_symlink(self) -> bool: ...
@@ -95,6 +109,9 @@ class Path(PurePath):
     def is_fifo(self) -> bool: ...
     def is_block_device(self) -> bool: ...
     def is_char_device(self) -> bool: ...
+    if sys.version_info >= (3, 12):
+        def is_junction(self) -> bool: ...
+
     def iterdir(self) -> Generator[Self, None, None]: ...
     def lchmod(self, mode: int) -> None: ...
     def lstat(self) -> stat_result: ...
@@ -159,6 +176,10 @@ class Path(PurePath):
         # so it's safer to pretend they don't exist
         def owner(self) -> str: ...
         def group(self) -> str: ...
+
+    # This method does "exist" on Windows on <3.12, but always raises NotImplementedError
+    # On py312+, it works properly on Windows, as with all other platforms
+    if sys.platform != "win32" or sys.version_info >= (3, 12):
         def is_mount(self) -> bool: ...
 
     if sys.version_info >= (3, 9):
@@ -171,7 +192,6 @@ class Path(PurePath):
         def replace(self, target: str | PurePath) -> None: ...
 
     def resolve(self, strict: bool = False) -> Self: ...
-    def rglob(self, pattern: str) -> Generator[Self, None, None]: ...
     def rmdir(self) -> None: ...
     def symlink_to(self, target: StrOrBytesPath, target_is_directory: bool = False) -> None: ...
     if sys.version_info >= (3, 10):
diff --git a/mypy/typeshed/stdlib/pdb.pyi b/mypy/typeshed/stdlib/pdb.pyi
index 405c45ca01ac2..e0d69e7d30fa6 100644
--- a/mypy/typeshed/stdlib/pdb.pyi
+++ b/mypy/typeshed/stdlib/pdb.pyi
@@ -168,7 +168,10 @@ class Pdb(Bdb, Cmd):
 def find_function(funcname: str, filename: str) -> tuple[str, str, int] | None: ...
 def main() -> None: ...
 def help() -> None: ...
-def getsourcelines(obj: _SourceObjectType) -> tuple[list[str], int]: ...
+
+if sys.version_info < (3, 10):
+    def getsourcelines(obj: _SourceObjectType) -> tuple[list[str], int]: ...
+
 def lasti2lineno(code: CodeType, lasti: int) -> int: ...
 
 class _rstr(str):
diff --git a/mypy/typeshed/stdlib/pkgutil.pyi b/mypy/typeshed/stdlib/pkgutil.pyi
index f9808c9e5de82..59f1f734cf90b 100644
--- a/mypy/typeshed/stdlib/pkgutil.pyi
+++ b/mypy/typeshed/stdlib/pkgutil.pyi
@@ -12,12 +12,12 @@ __all__ = [
     "walk_packages",
     "iter_modules",
     "get_data",
-    "ImpImporter",
-    "ImpLoader",
     "read_code",
     "extend_path",
     "ModuleInfo",
 ]
+if sys.version_info < (3, 12):
+    __all__ += ["ImpImporter", "ImpLoader"]
 
 _PathT = TypeVar("_PathT", bound=Iterable[str])
 
@@ -28,11 +28,12 @@ class ModuleInfo(NamedTuple):
 
 def extend_path(path: _PathT, name: str) -> _PathT: ...
 
-class ImpImporter:
-    def __init__(self, path: str | None = None) -> None: ...
+if sys.version_info < (3, 12):
+    class ImpImporter:
+        def __init__(self, path: str | None = None) -> None: ...
 
-class ImpLoader:
-    def __init__(self, fullname: str, file: IO[str], filename: str, etc: tuple[str, str, int]) -> None: ...
+    class ImpLoader:
+        def __init__(self, fullname: str, file: IO[str], filename: str, etc: tuple[str, str, int]) -> None: ...
 
 def find_loader(fullname: str) -> Loader | None: ...
 def get_importer(path_item: str) -> PathEntryFinder | None: ...
diff --git a/mypy/typeshed/stdlib/shutil.pyi b/mypy/typeshed/stdlib/shutil.pyi
index ef716d4049dd9..38c50d51b1299 100644
--- a/mypy/typeshed/stdlib/shutil.pyi
+++ b/mypy/typeshed/stdlib/shutil.pyi
@@ -2,6 +2,7 @@ import os
 import sys
 from _typeshed import BytesPath, FileDescriptorOrPath, StrOrBytesPath, StrPath, SupportsRead, SupportsWrite
 from collections.abc import Callable, Iterable, Sequence
+from tarfile import _TarfileFilter
 from typing import Any, AnyStr, NamedTuple, Protocol, TypeVar, overload
 from typing_extensions import TypeAlias
 
@@ -192,9 +193,9 @@ def register_archive_format(
 ) -> None: ...
 def unregister_archive_format(name: str) -> None: ...
 
-if sys.version_info >= (3, 12):
+if sys.version_info >= (3, 8):
     def unpack_archive(
-        filename: StrPath, extract_dir: StrPath | None = None, format: str | None = None, *, filter: str | None = None
+        filename: StrPath, extract_dir: StrPath | None = None, format: str | None = None, *, filter: _TarfileFilter | None = None
     ) -> None: ...
 
 else:
diff --git a/mypy/typeshed/stdlib/socket.pyi b/mypy/typeshed/stdlib/socket.pyi
index 6c897b919909d..e1ffc573b52e4 100644
--- a/mypy/typeshed/stdlib/socket.pyi
+++ b/mypy/typeshed/stdlib/socket.pyi
@@ -438,6 +438,36 @@ if sys.platform == "win32":
         SIO_LOOPBACK_FAST_PATH as SIO_LOOPBACK_FAST_PATH,
         SIO_RCVALL as SIO_RCVALL,
     )
+if sys.version_info >= (3, 12):
+    from _socket import (
+        IP_ADD_SOURCE_MEMBERSHIP as IP_ADD_SOURCE_MEMBERSHIP,
+        IP_BLOCK_SOURCE as IP_BLOCK_SOURCE,
+        IP_DROP_SOURCE_MEMBERSHIP as IP_DROP_SOURCE_MEMBERSHIP,
+        IP_PKTINFO as IP_PKTINFO,
+        IP_UNBLOCK_SOURCE as IP_UNBLOCK_SOURCE,
+    )
+
+    if sys.platform == "win32":
+        from _socket import (
+            HV_GUID_BROADCAST as HV_GUID_BROADCAST,
+            HV_GUID_CHILDREN as HV_GUID_CHILDREN,
+            HV_GUID_LOOPBACK as HV_GUID_LOOPBACK,
+            HV_GUID_PARENT as HV_GUID_PARENT,
+            HV_GUID_WILDCARD as HV_GUID_WILDCARD,
+            HV_GUID_ZERO as HV_GUID_ZERO,
+            HV_PROTOCOL_RAW as HV_PROTOCOL_RAW,
+            HVSOCKET_ADDRESS_FLAG_PASSTHRU as HVSOCKET_ADDRESS_FLAG_PASSTHRU,
+            HVSOCKET_CONNECT_TIMEOUT as HVSOCKET_CONNECT_TIMEOUT,
+            HVSOCKET_CONNECT_TIMEOUT_MAX as HVSOCKET_CONNECT_TIMEOUT_MAX,
+            HVSOCKET_CONNECTED_SUSPEND as HVSOCKET_CONNECTED_SUSPEND,
+        )
+    else:
+        from _socket import (
+            ETHERTYPE_ARP as ETHERTYPE_ARP,
+            ETHERTYPE_IP as ETHERTYPE_IP,
+            ETHERTYPE_IPV6 as ETHERTYPE_IPV6,
+            ETHERTYPE_VLAN as ETHERTYPE_VLAN,
+        )
 
 # Re-exported from errno
 EBADF: int
@@ -489,6 +519,8 @@ class AddressFamily(IntEnum):
         AF_LINK: int
         if sys.platform != "darwin":
             AF_BLUETOOTH: int
+    if sys.platform == "win32" and sys.version_info >= (3, 12):
+        AF_HYPERV: int
 
 AF_INET = AddressFamily.AF_INET
 AF_INET6 = AddressFamily.AF_INET6
@@ -540,6 +572,9 @@ if sys.platform != "win32" or sys.version_info >= (3, 9):
     if sys.platform != "darwin":
         AF_BLUETOOTH = AddressFamily.AF_BLUETOOTH
 
+if sys.platform == "win32" and sys.version_info >= (3, 12):
+    AF_HYPERV = AddressFamily.AF_HYPERV
+
 class SocketKind(IntEnum):
     SOCK_STREAM: int
     SOCK_DGRAM: int
diff --git a/mypy/typeshed/stdlib/socketserver.pyi b/mypy/typeshed/stdlib/socketserver.pyi
index 3799d82a0065e..6a932f66cd09a 100644
--- a/mypy/typeshed/stdlib/socketserver.pyi
+++ b/mypy/typeshed/stdlib/socketserver.pyi
@@ -28,6 +28,8 @@ if sys.platform != "win32":
         "UnixDatagramServer",
         "UnixStreamServer",
     ]
+    if sys.version_info >= (3, 12):
+        __all__ += ["ForkingUnixStreamServer", "ForkingUnixDatagramServer"]
 
 _RequestType: TypeAlias = _socket | tuple[bytes, _socket]
 _AfUnixAddress: TypeAlias = str | ReadableBuffer  # address acceptable for an AF_UNIX socket
@@ -124,6 +126,9 @@ class ThreadingMixIn:
 if sys.platform != "win32":
     class ForkingTCPServer(ForkingMixIn, TCPServer): ...
     class ForkingUDPServer(ForkingMixIn, UDPServer): ...
+    if sys.version_info >= (3, 12):
+        class ForkingUnixStreamServer(ForkingMixIn, UnixStreamServer): ...
+        class ForkingUnixDatagramServer(ForkingMixIn, UnixDatagramServer): ...
 
 class ThreadingTCPServer(ThreadingMixIn, TCPServer): ...
 class ThreadingUDPServer(ThreadingMixIn, UDPServer): ...
diff --git a/mypy/typeshed/stdlib/sys.pyi b/mypy/typeshed/stdlib/sys.pyi
index c2fdbeccca72c..ca049124053aa 100644
--- a/mypy/typeshed/stdlib/sys.pyi
+++ b/mypy/typeshed/stdlib/sys.pyi
@@ -321,7 +321,7 @@ if sys.version_info < (3, 9):
 
 if sys.version_info >= (3, 8):
     # Doesn't exist at runtime, but exported in the stubs so pytest etc. can annotate their code more easily.
-    class UnraisableHookArgs:
+    class UnraisableHookArgs(Protocol):
         exc_type: type[BaseException]
         exc_value: BaseException | None
         exc_traceback: TracebackType | None
@@ -359,3 +359,13 @@ if sys.version_info < (3, 8):
 # as part of the response to CVE-2020-10735
 def set_int_max_str_digits(maxdigits: int) -> None: ...
 def get_int_max_str_digits() -> int: ...
+
+if sys.version_info >= (3, 12):
+    def getunicodeinternedsize() -> int: ...
+    def deactivate_stack_trampoline() -> None: ...
+    def is_stack_trampoline_active() -> bool: ...
+    # It always exists, but raises on non-linux platforms:
+    if sys.platform == "linux":
+        def activate_stack_trampoline(__backend: str) -> None: ...
+    else:
+        def activate_stack_trampoline(__backend: str) -> NoReturn: ...
diff --git a/mypy/typeshed/stdlib/tarfile.pyi b/mypy/typeshed/stdlib/tarfile.pyi
index 5cf1d55cac63e..d9d9641ac6983 100644
--- a/mypy/typeshed/stdlib/tarfile.pyi
+++ b/mypy/typeshed/stdlib/tarfile.pyi
@@ -7,7 +7,7 @@ from collections.abc import Callable, Iterable, Iterator, Mapping
 from gzip import _ReadableFileobj as _GzipReadableFileobj, _WritableFileobj as _GzipWritableFileobj
 from types import TracebackType
 from typing import IO, ClassVar, Protocol, overload
-from typing_extensions import Literal, Self
+from typing_extensions import Literal, Self, TypeAlias
 
 __all__ = [
     "TarFile",
@@ -26,6 +26,21 @@ __all__ = [
     "DEFAULT_FORMAT",
     "open",
 ]
+if sys.version_info >= (3, 12):
+    __all__ += [
+        "fully_trusted_filter",
+        "data_filter",
+        "tar_filter",
+        "FilterError",
+        "AbsoluteLinkError",
+        "OutsideDestinationError",
+        "SpecialFileError",
+        "AbsolutePathError",
+        "LinkOutsideDestinationError",
+    ]
+
+_FilterFunction: TypeAlias = Callable[[TarInfo, str], TarInfo | None]
+_TarfileFilter: TypeAlias = Literal["fully_trusted", "tar", "data"] | _FilterFunction
 
 class _Fileobj(Protocol):
     def read(self, __size: int) -> bytes: ...
@@ -125,6 +140,7 @@ class TarFile:
     debug: int | None
     errorlevel: int | None
     offset: int  # undocumented
+    extraction_filter: _FilterFunction | None
     def __init__(
         self,
         name: StrOrBytesPath | None = None,
@@ -275,12 +291,32 @@ class TarFile:
     def getnames(self) -> _list[str]: ...
     def list(self, verbose: bool = True, *, members: _list[TarInfo] | None = None) -> None: ...
     def next(self) -> TarInfo | None: ...
-    def extractall(
-        self, path: StrOrBytesPath = ".", members: Iterable[TarInfo] | None = None, *, numeric_owner: bool = False
-    ) -> None: ...
-    def extract(
-        self, member: str | TarInfo, path: StrOrBytesPath = "", set_attrs: bool = True, *, numeric_owner: bool = False
-    ) -> None: ...
+    if sys.version_info >= (3, 8):
+        def extractall(
+            self,
+            path: StrOrBytesPath = ".",
+            members: Iterable[TarInfo] | None = None,
+            *,
+            numeric_owner: bool = False,
+            filter: _TarfileFilter | None = ...,
+        ) -> None: ...
+        def extract(
+            self,
+            member: str | TarInfo,
+            path: StrOrBytesPath = "",
+            set_attrs: bool = True,
+            *,
+            numeric_owner: bool = False,
+            filter: _TarfileFilter | None = ...,
+        ) -> None: ...
+    else:
+        def extractall(
+            self, path: StrOrBytesPath = ".", members: Iterable[TarInfo] | None = None, *, numeric_owner: bool = False
+        ) -> None: ...
+        def extract(
+            self, member: str | TarInfo, path: StrOrBytesPath = "", set_attrs: bool = True, *, numeric_owner: bool = False
+        ) -> None: ...
+
     def _extract_member(
         self, tarinfo: TarInfo, targetpath: str, set_attrs: bool = True, numeric_owner: bool = False
     ) -> None: ...  # undocumented
@@ -324,6 +360,31 @@ class StreamError(TarError): ...
 class ExtractError(TarError): ...
 class HeaderError(TarError): ...
 
+if sys.version_info >= (3, 8):
+    class FilterError(TarError):
+        # This attribute is only set directly on the subclasses, but the documentation guarantees
+        # that it is always present on FilterError.
+        tarinfo: TarInfo
+
+    class AbsolutePathError(FilterError):
+        def __init__(self, tarinfo: TarInfo) -> None: ...
+
+    class OutsideDestinationError(FilterError):
+        def __init__(self, tarinfo: TarInfo, path: str) -> None: ...
+
+    class SpecialFileError(FilterError):
+        def __init__(self, tarinfo: TarInfo) -> None: ...
+
+    class AbsoluteLinkError(FilterError):
+        def __init__(self, tarinfo: TarInfo) -> None: ...
+
+    class LinkOutsideDestinationError(FilterError):
+        def __init__(self, tarinfo: TarInfo, path: str) -> None: ...
+
+    def fully_trusted_filter(member: TarInfo, dest_path: str) -> TarInfo: ...
+    def tar_filter(member: TarInfo, dest_path: str) -> TarInfo: ...
+    def data_filter(member: TarInfo, dest_path: str) -> TarInfo: ...
+
 class TarInfo:
     name: str
     path: str
@@ -353,6 +414,21 @@ class TarInfo:
     def linkpath(self) -> str: ...
     @linkpath.setter
     def linkpath(self, linkname: str) -> None: ...
+    if sys.version_info >= (3, 8):
+        def replace(
+            self,
+            *,
+            name: str = ...,
+            mtime: int = ...,
+            mode: int = ...,
+            linkname: str = ...,
+            uid: int = ...,
+            gid: int = ...,
+            uname: str = ...,
+            gname: str = ...,
+            deep: bool = True,
+        ) -> Self: ...
+
     def get_info(self) -> Mapping[str, str | int | bytes | Mapping[str, str]]: ...
     if sys.version_info >= (3, 8):
         def tobuf(self, format: int | None = 2, encoding: str | None = "utf-8", errors: str = "surrogateescape") -> bytes: ...
diff --git a/mypy/typeshed/stdlib/tempfile.pyi b/mypy/typeshed/stdlib/tempfile.pyi
index cd27e91fbc75c..b251f8b9d0290 100644
--- a/mypy/typeshed/stdlib/tempfile.pyi
+++ b/mypy/typeshed/stdlib/tempfile.pyi
@@ -1,10 +1,21 @@
 import io
 import sys
-from _typeshed import BytesPath, GenericPath, ReadableBuffer, StrPath, WriteableBuffer
+from _typeshed import (
+    BytesPath,
+    GenericPath,
+    OpenBinaryMode,
+    OpenBinaryModeReading,
+    OpenBinaryModeUpdating,
+    OpenBinaryModeWriting,
+    OpenTextMode,
+    ReadableBuffer,
+    StrPath,
+    WriteableBuffer,
+)
 from collections.abc import Iterable, Iterator
 from types import TracebackType
 from typing import IO, Any, AnyStr, Generic, overload
-from typing_extensions import Literal, Self, TypeAlias
+from typing_extensions import Literal, Self
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -30,13 +41,54 @@ TMP_MAX: int
 tempdir: str | None
 template: str
 
-_StrMode: TypeAlias = Literal["r", "w", "a", "x", "r+", "w+", "a+", "x+", "rt", "wt", "at", "xt", "r+t", "w+t", "a+t", "x+t"]
-_BytesMode: TypeAlias = Literal["rb", "wb", "ab", "xb", "r+b", "w+b", "a+b", "x+b"]
+if sys.version_info >= (3, 12):
+    @overload
+    def NamedTemporaryFile(
+        mode: OpenTextMode,
+        buffering: int = -1,
+        encoding: str | None = None,
+        newline: str | None = None,
+        suffix: AnyStr | None = None,
+        prefix: AnyStr | None = None,
+        dir: GenericPath[AnyStr] | None = None,
+        delete: bool = True,
+        *,
+        errors: str | None = None,
+        delete_on_close: bool = True,
+    ) -> _TemporaryFileWrapper[str]: ...
+    @overload
+    def NamedTemporaryFile(
+        mode: OpenBinaryMode = "w+b",
+        buffering: int = -1,
+        encoding: str | None = None,
+        newline: str | None = None,
+        suffix: AnyStr | None = None,
+        prefix: AnyStr | None = None,
+        dir: GenericPath[AnyStr] | None = None,
+        delete: bool = True,
+        *,
+        errors: str | None = None,
+        delete_on_close: bool = True,
+    ) -> _TemporaryFileWrapper[bytes]: ...
+    @overload
+    def NamedTemporaryFile(
+        mode: str = "w+b",
+        buffering: int = -1,
+        encoding: str | None = None,
+        newline: str | None = None,
+        suffix: AnyStr | None = None,
+        prefix: AnyStr | None = None,
+        dir: GenericPath[AnyStr] | None = None,
+        delete: bool = True,
+        *,
+        errors: str | None = None,
+        delete_on_close: bool = True,
+    ) -> _TemporaryFileWrapper[Any]: ...
 
-if sys.version_info >= (3, 8):
+elif sys.version_info >= (3, 8):
     @overload
     def NamedTemporaryFile(
-        mode: _StrMode,
+        mode: OpenTextMode,
         buffering: int = -1,
         encoding: str | None = None,
         newline: str | None = None,
@@ -49,7 +101,7 @@ if sys.version_info >= (3, 8):
     ) -> _TemporaryFileWrapper[str]: ...
     @overload
     def NamedTemporaryFile(
-        mode: _BytesMode = "w+b",
+        mode: OpenBinaryMode = "w+b",
         buffering: int = -1,
         encoding: str | None = None,
         newline: str | None = None,
@@ -77,7 +129,7 @@ if sys.version_info >= (3, 8):
 else:
     @overload
     def NamedTemporaryFile(
-        mode: _StrMode,
+        mode: OpenTextMode,
         buffering: int = -1,
         encoding: str | None = None,
         newline: str | None = None,
@@ -88,7 +140,7 @@ else:
     ) -> _TemporaryFileWrapper[str]: ...
     @overload
     def NamedTemporaryFile(
-        mode: _BytesMode = "w+b",
+        mode: OpenBinaryMode = "w+b",
         buffering: int = -1,
         encoding: str | None = None,
         newline: str | None = None,
@@ -112,10 +164,11 @@ else:
 if sys.platform == "win32":
     TemporaryFile = NamedTemporaryFile
 else:
+    # See the comments for builtins.open() for an explanation of the overloads.
     if sys.version_info >= (3, 8):
         @overload
         def TemporaryFile(
-            mode: _StrMode,
+            mode: OpenTextMode,
             buffering: int = -1,
             encoding: str | None = None,
             newline: str | None = None,
@@ -124,11 +177,11 @@ else:
             dir: GenericPath[AnyStr] | None = None,
             *,
             errors: str | None = None,
-        ) -> IO[str]: ...
+        ) -> io.TextIOWrapper: ...
         @overload
         def TemporaryFile(
-            mode: _BytesMode = "w+b",
-            buffering: int = -1,
+            mode: OpenBinaryMode,
+            buffering: Literal[0],
             encoding: str | None = None,
             newline: str | None = None,
             suffix: AnyStr | None = None,
@@ -136,7 +189,54 @@ else:
             dir: GenericPath[AnyStr] | None = None,
             *,
             errors: str | None = None,
-        ) -> IO[bytes]: ...
+        ) -> io.FileIO: ...
+        @overload
+        def TemporaryFile(
+            *,
+            buffering: Literal[0],
+            encoding: str | None = None,
+            newline: str | None = None,
+            suffix: AnyStr | None = None,
+            prefix: AnyStr | None = None,
+            dir: GenericPath[AnyStr] | None = None,
+            errors: str | None = None,
+        ) -> io.FileIO: ...
+        @overload
+        def TemporaryFile(
+            mode: OpenBinaryModeWriting,
+            buffering: Literal[-1, 1] = -1,
+            encoding: str | None = None,
+            newline: str | None = None,
+            suffix: AnyStr | None = None,
+            prefix: AnyStr | None = None,
+            dir: GenericPath[AnyStr] | None = None,
+            *,
+            errors: str | None = None,
+        ) -> io.BufferedWriter: ...
+        @overload
+        def TemporaryFile(
+            mode: OpenBinaryModeReading,
+            buffering: Literal[-1, 1] = -1,
+            encoding: str | None = None,
+            newline: str | None = None,
+            suffix: AnyStr | None = None,
+            prefix: AnyStr | None = None,
+            dir: GenericPath[AnyStr] | None = None,
+            *,
+            errors: str | None = None,
+        ) -> io.BufferedReader: ...
+        @overload
+        def TemporaryFile(
+            mode: OpenBinaryModeUpdating = "w+b",
+            buffering: Literal[-1, 1] = -1,
+            encoding: str | None = None,
+            newline: str | None = None,
+            suffix: AnyStr | None = None,
+            prefix: AnyStr | None = None,
+            dir: GenericPath[AnyStr] | None = None,
+            *,
+            errors: str | None = None,
+        ) -> io.BufferedRandom: ...
         @overload
         def TemporaryFile(
             mode: str = "w+b",
@@ -152,40 +252,84 @@ else:
     else:
         @overload
         def TemporaryFile(
-            mode: _StrMode,
-            buffering: int = ...,
-            encoding: str | None = ...,
-            newline: str | None = ...,
-            suffix: AnyStr | None = ...,
-            prefix: AnyStr | None = ...,
-            dir: GenericPath[AnyStr] | None = ...,
-        ) -> IO[str]: ...
+            mode: OpenTextMode,
+            buffering: int = -1,
+            encoding: str | None = None,
+            newline: str | None = None,
+            suffix: AnyStr | None = None,
+            prefix: AnyStr | None = None,
+            dir: GenericPath[AnyStr] | None = None,
+        ) -> io.TextIOWrapper: ...
+        @overload
+        def TemporaryFile(
+            mode: OpenBinaryMode,
+            buffering: Literal[0],
+            encoding: str | None = None,
+            newline: str | None = None,
+            suffix: AnyStr | None = None,
+            prefix: AnyStr | None = None,
+            dir: GenericPath[AnyStr] | None = None,
+        ) -> io.FileIO: ...
+        @overload
+        def TemporaryFile(
+            *,
+            buffering: Literal[0],
+            encoding: str | None = None,
+            newline: str | None = None,
+            suffix: AnyStr | None = None,
+            prefix: AnyStr | None = None,
+            dir: GenericPath[AnyStr] | None = None,
+        ) -> io.FileIO: ...
+        @overload
+        def TemporaryFile(
+            mode: OpenBinaryModeUpdating = "w+b",
+            buffering: Literal[-1, 1] = -1,
+            encoding: str | None = None,
+            newline: str | None = None,
+            suffix: AnyStr | None = None,
+            prefix: AnyStr | None = None,
+            dir: GenericPath[AnyStr] | None = None,
+        ) -> io.BufferedRandom: ...
+        @overload
+        def TemporaryFile(
+            mode: OpenBinaryModeWriting,
+            buffering: Literal[-1, 1] = -1,
+            encoding: str | None = None,
+            newline: str | None = None,
+            suffix: AnyStr | None = None,
+            prefix: AnyStr | None = None,
+            dir: GenericPath[AnyStr] | None = None,
+        ) -> io.BufferedWriter: ...
         @overload
         def TemporaryFile(
-            mode: _BytesMode = ...,
-            buffering: int = ...,
-            encoding: str | None = ...,
-            newline: str | None = ...,
-            suffix: AnyStr | None = ...,
-            prefix: AnyStr | None = ...,
-            dir: GenericPath[AnyStr] | None = ...,
-        ) -> IO[bytes]: ...
+            mode: OpenBinaryModeReading,
+            buffering: Literal[-1, 1] = -1,
+            encoding: str | None = None,
+            newline: str | None = None,
+            suffix: AnyStr | None = None,
+            prefix: AnyStr | None = None,
+            dir: GenericPath[AnyStr] | None = None,
+        ) -> io.BufferedReader: ...
         @overload
         def TemporaryFile(
-            mode: str = ...,
-            buffering: int = ...,
-            encoding: str | None = ...,
-            newline: str | None = ...,
-            suffix: AnyStr | None = ...,
-            prefix: AnyStr | None = ...,
-            dir: GenericPath[AnyStr] | None = ...,
+            mode: str = "w+b",
+            buffering: int = -1,
+            encoding: str | None = None,
+            newline: str | None = None,
+            suffix: AnyStr | None = None,
+            prefix: AnyStr | None = None,
+            dir: GenericPath[AnyStr] | None = None,
         ) -> IO[Any]: ...
 
 class _TemporaryFileWrapper(Generic[AnyStr], IO[AnyStr]):
     file: IO[AnyStr]  # io.TextIOWrapper, io.BufferedReader or io.BufferedWriter
     name: str
     delete: bool
-    def __init__(self, file: IO[AnyStr], name: str, delete: bool = True) -> None: ...
+    if sys.version_info >= (3, 12):
+        def __init__(self, file: IO[AnyStr], name: str, delete: bool = True, delete_on_close: bool = True) -> None: ...
+    else:
+        def __init__(self, file: IO[AnyStr], name: str, delete: bool = True) -> None: ...
+
     def __enter__(self) -> Self: ...
     def __exit__(self, exc: type[BaseException] | None, value: BaseException | None, tb: TracebackType | None) -> None: ...
     def __getattr__(self, name: str) -> Any: ...
@@ -246,7 +390,7 @@ class SpooledTemporaryFile(IO[AnyStr], _SpooledTemporaryFileBase):
         def __init__(
             self: SpooledTemporaryFile[bytes],
             max_size: int = 0,
-            mode: _BytesMode = "w+b",
+            mode: OpenBinaryMode = "w+b",
             buffering: int = -1,
             encoding: str | None = None,
             newline: str | None = None,
@@ -260,7 +404,7 @@ class SpooledTemporaryFile(IO[AnyStr], _SpooledTemporaryFileBase):
         def __init__(
             self: SpooledTemporaryFile[str],
             max_size: int,
-            mode: _StrMode,
+            mode: OpenTextMode,
             buffering: int = -1,
             encoding: str | None = None,
             newline: str | None = None,
@@ -275,7 +419,7 @@ class SpooledTemporaryFile(IO[AnyStr], _SpooledTemporaryFileBase):
             self: SpooledTemporaryFile[str],
             max_size: int = 0,
             *,
-            mode: _StrMode,
+            mode: OpenTextMode,
             buffering: int = -1,
             encoding: str | None = None,
             newline: str | None = None,
@@ -319,7 +463,7 @@ class SpooledTemporaryFile(IO[AnyStr], _SpooledTemporaryFileBase):
         def __init__(
             self: SpooledTemporaryFile[bytes],
             max_size: int = 0,
-            mode: _BytesMode = "w+b",
+            mode: OpenBinaryMode = "w+b",
             buffering: int = -1,
             encoding: str | None = None,
             newline: str | None = None,
@@ -331,7 +475,7 @@ class SpooledTemporaryFile(IO[AnyStr], _SpooledTemporaryFileBase):
         def __init__(
             self: SpooledTemporaryFile[str],
             max_size: int,
-            mode: _StrMode,
+            mode: OpenTextMode,
             buffering: int = -1,
             encoding: str | None = None,
             newline: str | None = None,
@@ -344,7 +488,7 @@ class SpooledTemporaryFile(IO[AnyStr], _SpooledTemporaryFileBase):
             self: SpooledTemporaryFile[str],
             max_size: int = 0,
             *,
-            mode: _StrMode,
+            mode: OpenTextMode,
             buffering: int = -1,
             encoding: str | None = None,
             newline: str | None = None,
@@ -425,7 +569,28 @@ class SpooledTemporaryFile(IO[AnyStr], _SpooledTemporaryFileBase):
 
 class TemporaryDirectory(Generic[AnyStr]):
     name: AnyStr
-    if sys.version_info >= (3, 10):
+    if sys.version_info >= (3, 12):
+        @overload
+        def __init__(
+            self: TemporaryDirectory[str],
+            suffix: str | None = None,
+            prefix: str | None = None,
+            dir: StrPath | None = None,
+            ignore_cleanup_errors: bool = False,
+            *,
+            delete: bool = True,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self: TemporaryDirectory[bytes],
+            suffix: bytes | None = None,
+            prefix: bytes | None = None,
+            dir: BytesPath | None = None,
+            ignore_cleanup_errors: bool = False,
+            *,
+            delete: bool = True,
+        ) -> None: ...
+    elif sys.version_info >= (3, 10):
         @overload
         def __init__(
             self: TemporaryDirectory[str],
diff --git a/mypy/typeshed/stdlib/threading.pyi b/mypy/typeshed/stdlib/threading.pyi
index 6275e4552630d..badd09cae0518 100644
--- a/mypy/typeshed/stdlib/threading.pyi
+++ b/mypy/typeshed/stdlib/threading.pyi
@@ -37,6 +37,9 @@ if sys.version_info >= (3, 8):
 if sys.version_info >= (3, 10):
     __all__ += ["getprofile", "gettrace"]
 
+if sys.version_info >= (3, 12):
+    __all__ += ["setprofile_all_threads", "settrace_all_threads"]
+
 _profile_hook: ProfileFunction | None
 
 def active_count() -> int: ...
@@ -53,6 +56,10 @@ if sys.version_info >= (3, 8):
 def settrace(func: TraceFunction) -> None: ...
 def setprofile(func: ProfileFunction | None) -> None: ...
 
+if sys.version_info >= (3, 12):
+    def setprofile_all_threads(func: ProfileFunction | None) -> None: ...
+    def settrace_all_threads(func: TraceFunction) -> None: ...
+
 if sys.version_info >= (3, 10):
     def gettrace() -> TraceFunction | None: ...
     def getprofile() -> ProfileFunction | None: ...
diff --git a/mypy/typeshed/stdlib/token.pyi b/mypy/typeshed/stdlib/token.pyi
index fcd6ef87d2171..85867a2b97446 100644
--- a/mypy/typeshed/stdlib/token.pyi
+++ b/mypy/typeshed/stdlib/token.pyi
@@ -73,6 +73,9 @@ if sys.version_info >= (3, 8):
 if sys.version_info >= (3, 10):
     __all__ += ["SOFT_KEYWORD"]
 
+if sys.version_info >= (3, 12):
+    __all__ += ["EXCLAMATION", "FSTRING_END", "FSTRING_MIDDLE", "FSTRING_START"]
+
 ENDMARKER: int
 NAME: int
 NUMBER: int
@@ -145,6 +148,12 @@ if sys.version_info >= (3, 8):
 if sys.version_info >= (3, 10):
     SOFT_KEYWORD: int
 
+if sys.version_info >= (3, 12):
+    EXCLAMATION: int
+    FSTRING_END: int
+    FSTRING_MIDDLE: int
+    FSTRING_START: int
+
 def ISTERMINAL(x: int) -> bool: ...
 def ISNONTERMINAL(x: int) -> bool: ...
 def ISEOF(x: int) -> bool: ...
diff --git a/mypy/typeshed/stdlib/tokenize.pyi b/mypy/typeshed/stdlib/tokenize.pyi
index ba57402fb8455..0028ed034ae60 100644
--- a/mypy/typeshed/stdlib/tokenize.pyi
+++ b/mypy/typeshed/stdlib/tokenize.pyi
@@ -83,6 +83,9 @@ if sys.version_info >= (3, 8):
 if sys.version_info >= (3, 10):
     __all__ += ["SOFT_KEYWORD"]
 
+if sys.version_info >= (3, 12):
+    __all__ += ["EXCLAMATION", "FSTRING_END", "FSTRING_MIDDLE", "FSTRING_START"]
+
 if sys.version_info >= (3, 8):
     from token import EXACT_TOKEN_TYPES as EXACT_TOKEN_TYPES
 else:
diff --git a/mypy/typeshed/stdlib/types.pyi b/mypy/typeshed/stdlib/types.pyi
index 43475d91279dc..6909c765cb7d6 100644
--- a/mypy/typeshed/stdlib/types.pyi
+++ b/mypy/typeshed/stdlib/types.pyi
@@ -17,7 +17,7 @@ from importlib.machinery import ModuleSpec
 
 # pytype crashes if types.MappingProxyType inherits from collections.abc.Mapping instead of typing.Mapping
 from typing import Any, ClassVar, Generic, Mapping, Protocol, TypeVar, overload  # noqa: Y022
-from typing_extensions import Literal, ParamSpec, final
+from typing_extensions import Literal, ParamSpec, TypeVarTuple, final
 
 __all__ = [
     "FunctionType",
@@ -94,6 +94,8 @@ class FunctionType:
     if sys.version_info >= (3, 10):
         @property
         def __builtins__(self) -> dict[str, Any]: ...
+    if sys.version_info >= (3, 12):
+        __type_params__: tuple[TypeVar | ParamSpec | TypeVarTuple, ...]
 
     __module__: str
     def __init__(
@@ -374,6 +376,10 @@ class AsyncGeneratorType(AsyncGenerator[_T_co, _T_contra]):
     def ag_await(self) -> Awaitable[Any] | None: ...
     __name__: str
     __qualname__: str
+    if sys.version_info >= (3, 12):
+        @property
+        def ag_suspended(self) -> bool: ...
+
     def __aiter__(self) -> AsyncGeneratorType[_T_co, _T_contra]: ...
     def __anext__(self) -> Coroutine[Any, Any, _T_co]: ...
     def asend(self, __val: _T_contra) -> Coroutine[Any, Any, _T_co]: ...
diff --git a/mypy/typeshed/stdlib/typing.pyi b/mypy/typeshed/stdlib/typing.pyi
index db042dc440ae8..08d7da5e86225 100644
--- a/mypy/typeshed/stdlib/typing.pyi
+++ b/mypy/typeshed/stdlib/typing.pyi
@@ -631,6 +631,7 @@ class Mapping(Collection[_KT], Generic[_KT, _VT_co]):
     def keys(self) -> KeysView[_KT]: ...
     def values(self) -> ValuesView[_VT_co]: ...
     def __contains__(self, __key: object) -> bool: ...
+    def __eq__(self, __other: object) -> bool: ...
 
 class MutableMapping(Mapping[_KT, _VT], Generic[_KT, _VT]):
     @abstractmethod
@@ -853,9 +854,9 @@ class NamedTuple(tuple[Any, ...]):
     if sys.version_info >= (3, 12):
         __orig_bases__: ClassVar[tuple[Any, ...]]
     @overload
-    def __init__(self, typename: str, fields: Iterable[tuple[str, Any]] = ...) -> None: ...
+    def __init__(self, __typename: str, __fields: Iterable[tuple[str, Any]]) -> None: ...
     @overload
-    def __init__(self, typename: str, fields: None = None, **kwargs: Any) -> None: ...
+    def __init__(self, __typename: str, __fields: None = None, **kwargs: Any) -> None: ...
     @classmethod
     def _make(cls, iterable: Iterable[Any]) -> typing_extensions.Self: ...
     if sys.version_info >= (3, 8):
diff --git a/mypy/typeshed/stdlib/uuid.pyi b/mypy/typeshed/stdlib/uuid.pyi
index 935e44e80dfa9..74ce4ebd6b473 100644
--- a/mypy/typeshed/stdlib/uuid.pyi
+++ b/mypy/typeshed/stdlib/uuid.pyi
@@ -96,3 +96,6 @@ RESERVED_NCS: str
 RFC_4122: str
 RESERVED_MICROSOFT: str
 RESERVED_FUTURE: str
+
+if sys.version_info >= (3, 12):
+    def main() -> None: ...
diff --git a/mypy/typeshed/stdlib/webbrowser.pyi b/mypy/typeshed/stdlib/webbrowser.pyi
index 02edd42e7d598..99c7bb5846b62 100644
--- a/mypy/typeshed/stdlib/webbrowser.pyi
+++ b/mypy/typeshed/stdlib/webbrowser.pyi
@@ -43,8 +43,12 @@ class UnixBrowser(BaseBrowser):
 
 class Mozilla(UnixBrowser): ...
 
-class Galeon(UnixBrowser):
-    raise_opts: list[str]
+if sys.version_info < (3, 12):
+    class Galeon(UnixBrowser):
+        raise_opts: list[str]
+
+    class Grail(BaseBrowser):
+        def open(self, url: str, new: int = 0, autoraise: bool = True) -> bool: ...
 
 class Chrome(UnixBrowser): ...
 class Opera(UnixBrowser): ...
@@ -53,9 +57,6 @@ class Elinks(UnixBrowser): ...
 class Konqueror(BaseBrowser):
     def open(self, url: str, new: int = 0, autoraise: bool = True) -> bool: ...
 
-class Grail(BaseBrowser):
-    def open(self, url: str, new: int = 0, autoraise: bool = True) -> bool: ...
-
 if sys.platform == "win32":
     class WindowsDefault(BaseBrowser):
         def open(self, url: str, new: int = 0, autoraise: bool = True) -> bool: ...
diff --git a/mypy/typeshed/stdlib/zipimport.pyi b/mypy/typeshed/stdlib/zipimport.pyi
index ee97faace379e..0189bfe712b5a 100644
--- a/mypy/typeshed/stdlib/zipimport.pyi
+++ b/mypy/typeshed/stdlib/zipimport.pyi
@@ -17,8 +17,10 @@ class zipimporter:
     else:
         def __init__(self, path: StrOrBytesPath) -> None: ...
 
-    def find_loader(self, fullname: str, path: str | None = None) -> tuple[zipimporter | None, list[str]]: ...  # undocumented
-    def find_module(self, fullname: str, path: str | None = None) -> zipimporter | None: ...
+    if sys.version_info < (3, 12):
+        def find_loader(self, fullname: str, path: str | None = None) -> tuple[zipimporter | None, list[str]]: ...  # undocumented
+        def find_module(self, fullname: str, path: str | None = None) -> zipimporter | None: ...
+
     def get_code(self, fullname: str) -> CodeType: ...
     def get_data(self, pathname: str) -> bytes: ...
     def get_filename(self, fullname: str) -> str: ...
diff --git a/mypy/typeshed/stdlib/zoneinfo/__init__.pyi b/mypy/typeshed/stdlib/zoneinfo/__init__.pyi
index fe994be3e8ff4..a95530ed461ab 100644
--- a/mypy/typeshed/stdlib/zoneinfo/__init__.pyi
+++ b/mypy/typeshed/stdlib/zoneinfo/__init__.pyi
@@ -17,9 +17,9 @@ class ZoneInfo(tzinfo):
     @classmethod
     def no_cache(cls, key: str) -> Self: ...
     @classmethod
-    def from_file(cls, __fobj: _IOBytes, key: str | None = ...) -> Self: ...
+    def from_file(cls, __fobj: _IOBytes, key: str | None = None) -> Self: ...
     @classmethod
-    def clear_cache(cls, *, only_keys: Iterable[str] | None = ...) -> None: ...
+    def clear_cache(cls, *, only_keys: Iterable[str] | None = None) -> None: ...
     def tzname(self, __dt: datetime | None) -> str | None: ...
     def utcoffset(self, __dt: datetime | None) -> timedelta | None: ...
     def dst(self, __dt: datetime | None) -> timedelta | None: ...
@@ -30,7 +30,7 @@ class ZoneInfo(tzinfo):
 def reset_tzpath(to: Sequence[StrPath] | None = None) -> None: ...
 def available_timezones() -> set[str]: ...
 
-TZPATH: Sequence[str]
+TZPATH: tuple[str, ...]
 
 class ZoneInfoNotFoundError(KeyError): ...
 class InvalidTZPathWarning(RuntimeWarning): ...

From 6f913a148e1c1ec126d2009272a4a26ff61b8195 Mon Sep 17 00:00:00 2001
From: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
Date: Mon, 26 Sep 2022 12:55:07 -0700
Subject: [PATCH 034/129] Remove use of LiteralString in builtins (#13743)

---
 mypy/typeshed/stdlib/builtins.pyi | 93 -------------------------------
 1 file changed, 93 deletions(-)

diff --git a/mypy/typeshed/stdlib/builtins.pyi b/mypy/typeshed/stdlib/builtins.pyi
index b3871776128ad..3cbf54e2dd3d0 100644
--- a/mypy/typeshed/stdlib/builtins.pyi
+++ b/mypy/typeshed/stdlib/builtins.pyi
@@ -56,7 +56,6 @@ from typing import (  # noqa: Y022
 from typing_extensions import (  # type: ignore
     Concatenate,
     Literal,
-    LiteralString,
     ParamSpec,
     Self,
     SupportsIndex,
@@ -433,17 +432,8 @@ class str(Sequence[str]):
     def __new__(cls, object: object = ...) -> Self: ...
     @overload
     def __new__(cls, object: ReadableBuffer, encoding: str = ..., errors: str = ...) -> Self: ...
-    @overload
-    def capitalize(self: LiteralString) -> LiteralString: ...
-    @overload
     def capitalize(self) -> str: ...  # type: ignore[misc]
-    @overload
-    def casefold(self: LiteralString) -> LiteralString: ...
-    @overload
     def casefold(self) -> str: ...  # type: ignore[misc]
-    @overload
-    def center(self: LiteralString, __width: SupportsIndex, __fillchar: LiteralString = " ") -> LiteralString: ...
-    @overload
     def center(self, __width: SupportsIndex, __fillchar: str = " ") -> str: ...  # type: ignore[misc]
     def count(self, x: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
     def encode(self, encoding: str = "utf-8", errors: str = "strict") -> bytes: ...
@@ -451,20 +441,11 @@ class str(Sequence[str]):
         self, __suffix: str | tuple[str, ...], __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...
     ) -> bool: ...
     if sys.version_info >= (3, 8):
-        @overload
-        def expandtabs(self: LiteralString, tabsize: SupportsIndex = 8) -> LiteralString: ...
-        @overload
         def expandtabs(self, tabsize: SupportsIndex = 8) -> str: ...  # type: ignore[misc]
     else:
-        @overload
-        def expandtabs(self: LiteralString, tabsize: int = 8) -> LiteralString: ...
-        @overload
         def expandtabs(self, tabsize: int = 8) -> str: ...  # type: ignore[misc]
 
     def find(self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
-    @overload
-    def format(self: LiteralString, *args: LiteralString, **kwargs: LiteralString) -> LiteralString: ...
-    @overload
     def format(self, *args: object, **kwargs: object) -> str: ...  # type: ignore
     def format_map(self, map: _FormatMapMapping) -> str: ...
     def index(self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
@@ -480,91 +461,32 @@ class str(Sequence[str]):
     def isspace(self) -> bool: ...
     def istitle(self) -> bool: ...
     def isupper(self) -> bool: ...
-    @overload
-    def join(self: LiteralString, __iterable: Iterable[LiteralString]) -> LiteralString: ...
-    @overload
     def join(self, __iterable: Iterable[str]) -> str: ...  # type: ignore[misc]
-    @overload
-    def ljust(self: LiteralString, __width: SupportsIndex, __fillchar: LiteralString = " ") -> LiteralString: ...
-    @overload
     def ljust(self, __width: SupportsIndex, __fillchar: str = " ") -> str: ...  # type: ignore[misc]
-    @overload
-    def lower(self: LiteralString) -> LiteralString: ...
-    @overload
     def lower(self) -> str: ...  # type: ignore[misc]
-    @overload
-    def lstrip(self: LiteralString, __chars: LiteralString | None = None) -> LiteralString: ...
-    @overload
     def lstrip(self, __chars: str | None = None) -> str: ...  # type: ignore[misc]
-    @overload
-    def partition(self: LiteralString, __sep: LiteralString) -> tuple[LiteralString, LiteralString, LiteralString]: ...
-    @overload
     def partition(self, __sep: str) -> tuple[str, str, str]: ...  # type: ignore[misc]
-    @overload
-    def replace(
-        self: LiteralString, __old: LiteralString, __new: LiteralString, __count: SupportsIndex = -1
-    ) -> LiteralString: ...
-    @overload
     def replace(self, __old: str, __new: str, __count: SupportsIndex = -1) -> str: ...  # type: ignore[misc]
     if sys.version_info >= (3, 9):
-        @overload
-        def removeprefix(self: LiteralString, __prefix: LiteralString) -> LiteralString: ...
-        @overload
         def removeprefix(self, __prefix: str) -> str: ...  # type: ignore[misc]
-        @overload
-        def removesuffix(self: LiteralString, __suffix: LiteralString) -> LiteralString: ...
-        @overload
         def removesuffix(self, __suffix: str) -> str: ...  # type: ignore[misc]
 
     def rfind(self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
     def rindex(self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
-    @overload
-    def rjust(self: LiteralString, __width: SupportsIndex, __fillchar: LiteralString = " ") -> LiteralString: ...
-    @overload
     def rjust(self, __width: SupportsIndex, __fillchar: str = " ") -> str: ...  # type: ignore[misc]
-    @overload
-    def rpartition(self: LiteralString, __sep: LiteralString) -> tuple[LiteralString, LiteralString, LiteralString]: ...
-    @overload
     def rpartition(self, __sep: str) -> tuple[str, str, str]: ...  # type: ignore[misc]
-    @overload
-    def rsplit(self: LiteralString, sep: LiteralString | None = None, maxsplit: SupportsIndex = -1) -> list[LiteralString]: ...
-    @overload
     def rsplit(self, sep: str | None = None, maxsplit: SupportsIndex = -1) -> list[str]: ...  # type: ignore[misc]
-    @overload
-    def rstrip(self: LiteralString, __chars: LiteralString | None = None) -> LiteralString: ...
-    @overload
     def rstrip(self, __chars: str | None = None) -> str: ...  # type: ignore[misc]
-    @overload
-    def split(self: LiteralString, sep: LiteralString | None = None, maxsplit: SupportsIndex = -1) -> list[LiteralString]: ...
-    @overload
     def split(self, sep: str | None = None, maxsplit: SupportsIndex = -1) -> list[str]: ...  # type: ignore[misc]
-    @overload
-    def splitlines(self: LiteralString, keepends: bool = False) -> list[LiteralString]: ...
-    @overload
     def splitlines(self, keepends: bool = False) -> list[str]: ...  # type: ignore[misc]
     def startswith(
         self, __prefix: str | tuple[str, ...], __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...
     ) -> bool: ...
-    @overload
-    def strip(self: LiteralString, __chars: LiteralString | None = None) -> LiteralString: ...
-    @overload
     def strip(self, __chars: str | None = None) -> str: ...  # type: ignore[misc]
-    @overload
-    def swapcase(self: LiteralString) -> LiteralString: ...
-    @overload
     def swapcase(self) -> str: ...  # type: ignore[misc]
-    @overload
-    def title(self: LiteralString) -> LiteralString: ...
-    @overload
     def title(self) -> str: ...  # type: ignore[misc]
     def translate(self, __table: _TranslateTable) -> str: ...
-    @overload
-    def upper(self: LiteralString) -> LiteralString: ...
-    @overload
     def upper(self) -> str: ...  # type: ignore[misc]
-    @overload
-    def zfill(self: LiteralString, __width: SupportsIndex) -> LiteralString: ...
-    @overload
     def zfill(self, __width: SupportsIndex) -> str: ...  # type: ignore[misc]
     @staticmethod
     @overload
@@ -575,9 +497,6 @@ class str(Sequence[str]):
     @staticmethod
     @overload
     def maketrans(__x: str, __y: str, __z: str) -> dict[int, int | None]: ...
-    @overload
-    def __add__(self: LiteralString, __value: LiteralString) -> LiteralString: ...
-    @overload
     def __add__(self, __value: str) -> str: ...  # type: ignore[misc]
     # Incompatible with Sequence.__contains__
     def __contains__(self, __key: str) -> bool: ...  # type: ignore[override]
@@ -585,25 +504,13 @@ class str(Sequence[str]):
     def __ge__(self, __value: str) -> bool: ...
     def __getitem__(self, __key: SupportsIndex | slice) -> str: ...
     def __gt__(self, __value: str) -> bool: ...
-    @overload
-    def __iter__(self: LiteralString) -> Iterator[LiteralString]: ...
-    @overload
     def __iter__(self) -> Iterator[str]: ...  # type: ignore[misc]
     def __le__(self, __value: str) -> bool: ...
     def __len__(self) -> int: ...
     def __lt__(self, __value: str) -> bool: ...
-    @overload
-    def __mod__(self: LiteralString, __value: LiteralString | tuple[LiteralString, ...]) -> LiteralString: ...
-    @overload
     def __mod__(self, __value: Any) -> str: ...  # type: ignore
-    @overload
-    def __mul__(self: LiteralString, __value: SupportsIndex) -> LiteralString: ...
-    @overload
     def __mul__(self, __value: SupportsIndex) -> str: ...  # type: ignore[misc]
     def __ne__(self, __value: object) -> bool: ...
-    @overload
-    def __rmul__(self: LiteralString, __value: SupportsIndex) -> LiteralString: ...
-    @overload
     def __rmul__(self, __value: SupportsIndex) -> str: ...  # type: ignore[misc]
     def __getnewargs__(self) -> tuple[str]: ...
 

From 475a46a7820e1ff7990a23c6ae745acbb3678c18 Mon Sep 17 00:00:00 2001
From: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
Date: Sat, 29 Oct 2022 12:47:21 -0700
Subject: [PATCH 035/129] Revert sum literal integer change (#13961)

This is allegedly causing large performance problems, see 13821

typeshed/8231 had zero hits on mypy_primer, so it's not the worst thing
to undo. Patching this in typeshed also feels weird, since there's a
more general soundness issue. If a typevar has a bound or constraint, we
might not want to solve it to a Literal.

If we can confirm the performance regression or fix the unsoundness
within mypy, I might pursue upstreaming this in typeshed.

(Reminder: add this to the sync_typeshed script once merged)
---
 mypy/typeshed/stdlib/builtins.pyi | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/mypy/typeshed/stdlib/builtins.pyi b/mypy/typeshed/stdlib/builtins.pyi
index 3cbf54e2dd3d0..4337a44c7c684 100644
--- a/mypy/typeshed/stdlib/builtins.pyi
+++ b/mypy/typeshed/stdlib/builtins.pyi
@@ -1665,11 +1665,11 @@ _SupportsSumNoDefaultT = TypeVar("_SupportsSumNoDefaultT", bound=_SupportsSumWit
 # Instead, we special-case the most common examples of this: bool and literal integers.
 if sys.version_info >= (3, 8):
     @overload
-    def sum(__iterable: Iterable[bool | _LiteralInteger], start: int = 0) -> int: ...  # type: ignore[misc]
+    def sum(__iterable: Iterable[bool], start: int = 0) -> int: ...  # type: ignore[misc]
 
 else:
     @overload
-    def sum(__iterable: Iterable[bool | _LiteralInteger], __start: int = 0) -> int: ...  # type: ignore[misc]
+    def sum(__iterable: Iterable[bool], __start: int = 0) -> int: ...  # type: ignore[misc]
 
 @overload
 def sum(__iterable: Iterable[_SupportsSumNoDefaultT]) -> _SupportsSumNoDefaultT | Literal[0]: ...

From f5e5c117de36a339209c885d44b1b784e17023a4 Mon Sep 17 00:00:00 2001
From: AlexWaygood <alex.waygood@gmail.com>
Date: Mon, 1 May 2023 20:34:55 +0100
Subject: [PATCH 036/129] Revert typeshed ctypes change Since the plugin
 provides superior type checking:
 https://github.com/python/mypy/pull/13987#issuecomment-1310863427 A manual
 cherry-pick of e437cdf.

---
 mypy/typeshed/stdlib/_ctypes.pyi | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/mypy/typeshed/stdlib/_ctypes.pyi b/mypy/typeshed/stdlib/_ctypes.pyi
index 25d604218a00d..756ee86d33429 100644
--- a/mypy/typeshed/stdlib/_ctypes.pyi
+++ b/mypy/typeshed/stdlib/_ctypes.pyi
@@ -151,11 +151,7 @@ class Array(Generic[_CT], _CData):
     def _type_(self) -> type[_CT]: ...
     @_type_.setter
     def _type_(self, value: type[_CT]) -> None: ...
-    # Note: only available if _CT == c_char
-    @property
-    def raw(self) -> bytes: ...
-    @raw.setter
-    def raw(self, value: ReadableBuffer) -> None: ...
+    raw: bytes  # Note: only available if _CT == c_char
     value: Any  # Note: bytes if _CT == c_char, str if _CT == c_wchar, unavailable otherwise
     # TODO These methods cannot be annotated correctly at the moment.
     # All of these "Any"s stand for the array's element type, but it's not possible to use _CT

From 9f3bbbeb1f5c8ca70f9d0386d5d1091f23e9a7cc Mon Sep 17 00:00:00 2001
From: AlexWaygood <alex.waygood@gmail.com>
Date: Sat, 4 Mar 2023 13:14:11 +0000
Subject: [PATCH 037/129] Revert use of `ParamSpec` for `functools.wraps`

---
 mypy/typeshed/stdlib/functools.pyi | 40 +++++++++++-------------------
 1 file changed, 14 insertions(+), 26 deletions(-)

diff --git a/mypy/typeshed/stdlib/functools.pyi b/mypy/typeshed/stdlib/functools.pyi
index 8adc3d82292e2..1b4e59b7c1204 100644
--- a/mypy/typeshed/stdlib/functools.pyi
+++ b/mypy/typeshed/stdlib/functools.pyi
@@ -1,9 +1,9 @@
 import sys
 import types
-from _typeshed import SupportsAllComparisons, SupportsItems
+from _typeshed import IdentityFunction, SupportsAllComparisons, SupportsItems
 from collections.abc import Callable, Hashable, Iterable, Sequence, Sized
 from typing import Any, Generic, NamedTuple, TypeVar, overload
-from typing_extensions import Literal, ParamSpec, Self, TypeAlias, TypedDict, final
+from typing_extensions import Literal, Self, TypeAlias, TypedDict, final
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -28,12 +28,10 @@ if sys.version_info >= (3, 8):
 if sys.version_info >= (3, 9):
     __all__ += ["cache"]
 
+_AnyCallable: TypeAlias = Callable[..., object]
+
 _T = TypeVar("_T")
 _S = TypeVar("_S")
-_PWrapped = ParamSpec("_PWrapped")
-_RWrapped = TypeVar("_RWrapped")
-_PWrapper = ParamSpec("_PWrapper")
-_RWapper = TypeVar("_RWapper")
 
 @overload
 def reduce(function: Callable[[_T, _S], _T], sequence: Iterable[_S], initial: _T) -> _T: ...
@@ -87,41 +85,31 @@ else:
     ]
 WRAPPER_UPDATES: tuple[Literal["__dict__"]]
 
-class _Wrapped(Generic[_PWrapped, _RWrapped, _PWrapper, _RWapper]):
-    __wrapped__: Callable[_PWrapped, _RWrapped]
-    def __call__(self, *args: _PWrapper.args, **kwargs: _PWrapper.kwargs) -> _RWapper: ...
-    # as with ``Callable``, we'll assume that these attributes exist
-    __name__: str
-    __qualname__: str
-
-class _Wrapper(Generic[_PWrapped, _RWrapped]):
-    def __call__(self, f: Callable[_PWrapper, _RWapper]) -> _Wrapped[_PWrapped, _RWrapped, _PWrapper, _RWapper]: ...
-
 if sys.version_info >= (3, 12):
     def update_wrapper(
-        wrapper: Callable[_PWrapper, _RWapper],
-        wrapped: Callable[_PWrapped, _RWrapped],
+        wrapper: _T,
+        wrapped: _AnyCallable,
         assigned: Sequence[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__", "__type_params__"),
         updated: Sequence[str] = ("__dict__",),
-    ) -> _Wrapped[_PWrapped, _RWrapped, _PWrapper, _RWapper]: ...
+    ) -> _T: ...
     def wraps(
-        wrapped: Callable[_PWrapped, _RWrapped],
+        wrapped: _AnyCallable,
         assigned: Sequence[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__", "__type_params__"),
         updated: Sequence[str] = ("__dict__",),
-    ) -> _Wrapper[_PWrapped, _RWrapped]: ...
+    ) -> IdentityFunction: ...
 
 else:
     def update_wrapper(
-        wrapper: Callable[_PWrapper, _RWapper],
-        wrapped: Callable[_PWrapped, _RWrapped],
+        wrapper: _T,
+        wrapped: _AnyCallable,
         assigned: Sequence[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__"),
         updated: Sequence[str] = ("__dict__",),
-    ) -> _Wrapped[_PWrapped, _RWrapped, _PWrapper, _RWapper]: ...
+    ) -> _T: ...
     def wraps(
-        wrapped: Callable[_PWrapped, _RWrapped],
+        wrapped: _AnyCallable,
         assigned: Sequence[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__"),
         updated: Sequence[str] = ("__dict__",),
-    ) -> _Wrapper[_PWrapped, _RWrapped]: ...
+    ) -> IdentityFunction: ...
 
 def total_ordering(cls: type[_T]) -> type[_T]: ...
 def cmp_to_key(mycmp: Callable[[_T, _T], int]) -> Callable[[_T], SupportsAllComparisons]: ...

From bf9230934c4ce68c8c01aa0dd6aef57b180cc08b Mon Sep 17 00:00:00 2001
From: Alex Waygood <Alex.Waygood@Gmail.com>
Date: Thu, 15 Jun 2023 21:12:18 +0100
Subject: [PATCH 038/129] Update hashes in `misc/sync-typeshed.py` following
 typeshed sync (#15447)

Followup to #15444
---
 misc/sync-typeshed.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/misc/sync-typeshed.py b/misc/sync-typeshed.py
index fc6cbc1d88e72..a8aca425696a9 100644
--- a/misc/sync-typeshed.py
+++ b/misc/sync-typeshed.py
@@ -179,10 +179,10 @@ def main() -> None:
     print("Created typeshed sync commit.")
 
     commits_to_cherry_pick = [
-        "c844270a4",  # LiteralString reverts
-        "9ebe5fd49",  # sum reverts
-        "d1987191f",  # ctypes reverts
-        "b1761f4c9",  # ParamSpec for functools.wraps
+        "6f913a148",  # LiteralString reverts
+        "475a46a78",  # sum reverts
+        "f5e5c117d",  # ctypes reverts
+        "9f3bbbeb1",  # ParamSpec for functools.wraps
     ]
     for commit in commits_to_cherry_pick:
         subprocess.run(["git", "cherry-pick", commit], check=True)

From ceb4d7fd687ddbb94dc6c62fb6a2c46c383da54f Mon Sep 17 00:00:00 2001
From: Ivan Levkivskyi <levkivskyi@gmail.com>
Date: Thu, 15 Jun 2023 21:32:37 +0100
Subject: [PATCH 039/129] Fix re-added file with errors in mypy daemon (#15440)

Fixes #5343
Fixes #12249

This can potentially slow down runs in situations where multiple
unchanged files are re-added to source list. Potentially, we can track
whether modules had errors permanently (not just from previous run), and
then only re-check those unchanged re-added files that had errors
before. I am not sure if this is important.
---
 mypy/dmypy_server.py             | 15 +++++++++++++++
 test-data/unit/daemon.test       | 22 ++++++++++++++++++++++
 test-data/unit/fine-grained.test | 21 +++++++++++++++++++++
 3 files changed, 58 insertions(+)

diff --git a/mypy/dmypy_server.py b/mypy/dmypy_server.py
index 631aab4ccbc82..54544f4c01ce4 100644
--- a/mypy/dmypy_server.py
+++ b/mypy/dmypy_server.py
@@ -857,6 +857,21 @@ def _find_changed(
             assert path
             removed.append((source.module, path))
 
+        # Always add modules that were (re-)added, since they may be detected as not changed by
+        # fswatcher (if they were actually not changed), but they may still need to be checked
+        # in case they had errors before they were deleted from sources on previous runs.
+        previous_modules = {source.module for source in self.previous_sources}
+        changed_set = set(changed)
+        changed.extend(
+            [
+                (source.module, source.path)
+                for source in sources
+                if source.path
+                and source.module not in previous_modules
+                and (source.module, source.path) not in changed_set
+            ]
+        )
+
         # Find anything that has had its module path change because of added or removed __init__s
         last = {s.path: s.module for s in self.previous_sources}
         for s in sources:
diff --git a/test-data/unit/daemon.test b/test-data/unit/daemon.test
index 424fc6d2b167b..1fae1514111c4 100644
--- a/test-data/unit/daemon.test
+++ b/test-data/unit/daemon.test
@@ -62,6 +62,28 @@ Daemon started
 \[mypy]
 files = ./foo.py
 
+[case testDaemonRunMultipleStrict]
+$ dmypy run -- foo.py --strict --follow-imports=error
+Daemon started
+foo.py:1: error: Function is missing a return type annotation
+foo.py:1: note: Use "-> None" if function does not return a value
+Found 1 error in 1 file (checked 1 source file)
+== Return code: 1
+$ dmypy run -- bar.py --strict --follow-imports=error
+bar.py:1: error: Function is missing a return type annotation
+bar.py:1: note: Use "-> None" if function does not return a value
+Found 1 error in 1 file (checked 1 source file)
+== Return code: 1
+$ dmypy run -- foo.py --strict --follow-imports=error
+foo.py:1: error: Function is missing a return type annotation
+foo.py:1: note: Use "-> None" if function does not return a value
+Found 1 error in 1 file (checked 1 source file)
+== Return code: 1
+[file foo.py]
+def f(): pass
+[file bar.py]
+def f(): pass
+
 [case testDaemonRunRestart]
 $ dmypy run -- foo.py --follow-imports=error
 Daemon started
diff --git a/test-data/unit/fine-grained.test b/test-data/unit/fine-grained.test
index 88a11be31f340..a0d7d302fd08b 100644
--- a/test-data/unit/fine-grained.test
+++ b/test-data/unit/fine-grained.test
@@ -10340,3 +10340,24 @@ reveal_type(x)
 [out]
 ==
 a.py:3: note: Revealed type is "Union[def (x: builtins.int) -> builtins.int, def (*x: builtins.int) -> builtins.int]"
+
+[case testErrorInReAddedModule]
+# flags: --disallow-untyped-defs --follow-imports=error
+# cmd: mypy a.py
+# cmd2: mypy b.py
+# cmd3: mypy a.py
+
+[file a.py]
+def f(): pass
+[file b.py]
+def f(): pass
+[file unrelated.txt.3]
+[out]
+a.py:1: error: Function is missing a return type annotation
+a.py:1: note: Use "-> None" if function does not return a value
+==
+b.py:1: error: Function is missing a return type annotation
+b.py:1: note: Use "-> None" if function does not return a value
+==
+a.py:1: error: Function is missing a return type annotation
+a.py:1: note: Use "-> None" if function does not return a value

From cfec71798175fcbf030d6d114750d6fac454b3c9 Mon Sep 17 00:00:00 2001
From: Adel Atallah <2213999+atallahade@users.noreply.github.com>
Date: Thu, 15 Jun 2023 21:43:01 +0100
Subject: [PATCH 040/129] Remove confusing instance variable example in cheat
 sheet (#15441)

---
 docs/source/cheat_sheet_py3.rst | 2 --
 1 file changed, 2 deletions(-)

diff --git a/docs/source/cheat_sheet_py3.rst b/docs/source/cheat_sheet_py3.rst
index 31242d0ad0bc6..297427e72aca2 100644
--- a/docs/source/cheat_sheet_py3.rst
+++ b/docs/source/cheat_sheet_py3.rst
@@ -178,8 +178,6 @@ Classes
    class AuditedBankAccount(BankAccount):
        # You can optionally declare instance variables in the class body
        audit_log: list[str]
-       # This is an instance variable with a default value
-       auditor_name: str = "The Spanish Inquisition"
 
        def __init__(self, account_name: str, initial_balance: int = 0) -> None:
            super().__init__(account_name, initial_balance)

From 65a715a650cc058daad93e123ce972d99088f19f Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Fri, 16 Jun 2023 13:42:15 +0100
Subject: [PATCH 041/129] [mypyc] Use C99 compound literals for undefined tuple
 values (#15453)

This simplifies things a bit. All the C compilers we care about should
support this.

This will make things easier once we support more types represented as C
structs.

I expect this to have no measurable impact on performance.
---
 mypyc/codegen/emit.py       | 35 +++++++++++++----------------------
 mypyc/codegen/emitmodule.py |  8 ++------
 mypyc/lib-rt/CPy.h          |  3 ---
 mypyc/test/test_emit.py     | 20 +++++++++++++++++++-
 4 files changed, 34 insertions(+), 32 deletions(-)

diff --git a/mypyc/codegen/emit.py b/mypyc/codegen/emit.py
index a2e3d9849dca2..8114e05172199 100644
--- a/mypyc/codegen/emit.py
+++ b/mypyc/codegen/emit.py
@@ -345,12 +345,6 @@ def tuple_c_declaration(self, rtuple: RTuple) -> list[str]:
                 result.append(f"{self.ctype_spaced(typ)}f{i};")
                 i += 1
         result.append(f"}} {rtuple.struct_name};")
-        values = self.tuple_undefined_value_helper(rtuple)
-        result.append(
-            "static {} {} = {{ {} }};".format(
-                self.ctype(rtuple), self.tuple_undefined_value(rtuple), "".join(values)
-            )
-        )
         result.append("#endif")
         result.append("")
 
@@ -470,23 +464,20 @@ def tuple_undefined_check_cond(
             return check
 
     def tuple_undefined_value(self, rtuple: RTuple) -> str:
-        return "tuple_undefined_" + rtuple.unique_id
+        """Undefined tuple value suitable in an expression."""
+        return f"({rtuple.struct_name}) {self.c_initializer_undefined_value(rtuple)}"
 
-    def tuple_undefined_value_helper(self, rtuple: RTuple) -> list[str]:
-        res = []
-        # see tuple_c_declaration()
-        if len(rtuple.types) == 0:
-            return [self.c_undefined_value(int_rprimitive)]
-        for item in rtuple.types:
-            if not isinstance(item, RTuple):
-                res.append(self.c_undefined_value(item))
-            else:
-                sub_list = self.tuple_undefined_value_helper(item)
-                res.append("{ ")
-                res.extend(sub_list)
-                res.append(" }")
-            res.append(", ")
-        return res[:-1]
+    def c_initializer_undefined_value(self, rtype: RType) -> str:
+        """Undefined value represented in a form suitable for variable initialization."""
+        if isinstance(rtype, RTuple):
+            if not rtype.types:
+                # Empty tuples contain a flag so that they can still indicate
+                # error values.
+                return f"{{ {int_rprimitive.c_undefined} }}"
+            items = ", ".join([self.c_initializer_undefined_value(t) for t in rtype.types])
+            return f"{{ {items} }}"
+        else:
+            return self.c_undefined_value(rtype)
 
     # Higher-level operations
 
diff --git a/mypyc/codegen/emitmodule.py b/mypyc/codegen/emitmodule.py
index 0e80ff6da1f24..f360fabbe8f66 100644
--- a/mypyc/codegen/emitmodule.py
+++ b/mypyc/codegen/emitmodule.py
@@ -51,7 +51,7 @@
 from mypyc.ir.func_ir import FuncIR
 from mypyc.ir.module_ir import ModuleIR, ModuleIRs, deserialize_modules
 from mypyc.ir.ops import DeserMaps, LoadLiteral
-from mypyc.ir.rtypes import RTuple, RType
+from mypyc.ir.rtypes import RType
 from mypyc.irbuild.main import build_ir
 from mypyc.irbuild.mapper import Mapper
 from mypyc.irbuild.prepare import load_type_map
@@ -1052,11 +1052,7 @@ def declare_finals(
     def final_definition(self, module: str, name: str, typ: RType, emitter: Emitter) -> str:
         static_name = emitter.static_name(name, module)
         # Here we rely on the fact that undefined value and error value are always the same
-        if isinstance(typ, RTuple):
-            # We need to inline because initializer must be static
-            undefined = "{{ {} }}".format("".join(emitter.tuple_undefined_value_helper(typ)))
-        else:
-            undefined = emitter.c_undefined_value(typ)
+        undefined = emitter.c_initializer_undefined_value(typ)
         return f"{emitter.ctype_spaced(typ)}{static_name} = {undefined};"
 
     def declare_static_pyobject(self, identifier: str, emitter: Emitter) -> None:
diff --git a/mypyc/lib-rt/CPy.h b/mypyc/lib-rt/CPy.h
index 7a3e16fe9d658..30d93be609894 100644
--- a/mypyc/lib-rt/CPy.h
+++ b/mypyc/lib-rt/CPy.h
@@ -41,7 +41,6 @@ typedef struct tuple_T3OOO {
     PyObject *f1;
     PyObject *f2;
 } tuple_T3OOO;
-static tuple_T3OOO tuple_undefined_T3OOO = { NULL, NULL, NULL };
 #endif
 
 // Our return tuple wrapper for dictionary iteration helper.
@@ -52,7 +51,6 @@ typedef struct tuple_T3CIO {
     CPyTagged f1;  // Last dict offset
     PyObject *f2;  // Next dictionary key or value
 } tuple_T3CIO;
-static tuple_T3CIO tuple_undefined_T3CIO = { 2, CPY_INT_TAG, NULL };
 #endif
 
 // Same as above but for both key and value.
@@ -64,7 +62,6 @@ typedef struct tuple_T4CIOO {
     PyObject *f2;  // Next dictionary key
     PyObject *f3;  // Next dictionary value
 } tuple_T4CIOO;
-static tuple_T4CIOO tuple_undefined_T4CIOO = { 2, CPY_INT_TAG, NULL, NULL };
 #endif
 
 
diff --git a/mypyc/test/test_emit.py b/mypyc/test/test_emit.py
index 54bf4eef3c74a..e4ace3ec01f02 100644
--- a/mypyc/test/test_emit.py
+++ b/mypyc/test/test_emit.py
@@ -4,7 +4,7 @@
 
 from mypyc.codegen.emit import Emitter, EmitterContext
 from mypyc.ir.ops import BasicBlock, Register, Value
-from mypyc.ir.rtypes import int_rprimitive
+from mypyc.ir.rtypes import RTuple, bool_rprimitive, int_rprimitive, str_rprimitive
 from mypyc.namegen import NameGenerator
 
 
@@ -49,3 +49,21 @@ def test_emit_line(self) -> None:
 CPyStatics[1]; /* [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
                   21, 22, 23, 24, 25, 26, 27, 28, 29] */\n"""
         )
+
+    def test_emit_undefined_value_for_simple_type(self) -> None:
+        emitter = Emitter(self.context, {})
+        assert emitter.c_undefined_value(int_rprimitive) == "CPY_INT_TAG"
+        assert emitter.c_undefined_value(str_rprimitive) == "NULL"
+        assert emitter.c_undefined_value(bool_rprimitive) == "2"
+
+    def test_emit_undefined_value_for_tuple(self) -> None:
+        emitter = Emitter(self.context, {})
+        assert (
+            emitter.c_undefined_value(RTuple([str_rprimitive, int_rprimitive, bool_rprimitive]))
+            == "(tuple_T3OIC) { NULL, CPY_INT_TAG, 2 }"
+        )
+        assert emitter.c_undefined_value(RTuple([str_rprimitive])) == "(tuple_T1O) { NULL }"
+        assert (
+            emitter.c_undefined_value(RTuple([RTuple([str_rprimitive]), bool_rprimitive]))
+            == "(tuple_T2T1OC) { { NULL }, 2 }"
+        )

From db5b5af1201fff03465b0684d16b6489a62a3d78 Mon Sep 17 00:00:00 2001
From: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
Date: Fri, 16 Jun 2023 06:02:39 -0700
Subject: [PATCH 042/129] Switch PEP 561 tests to a different build backend
 (#15451)

Fixes #15446

setuptools has broken how editable installs work. It seems like most
other build backends continue to use static pth files, so let's just
switch to another one.
---
 mypy/test/testpep561.py                       | 32 +++++++++----------
 .../packages/typedpkg-stubs/pyproject.toml    | 11 +++++++
 test-data/packages/typedpkg-stubs/setup.py    | 13 --------
 test-data/packages/typedpkg/pyproject.toml    |  8 +++++
 test-data/packages/typedpkg/setup.py          | 15 ---------
 .../packages/typedpkg_ns_a/pyproject.toml     | 11 +++++++
 test-data/packages/typedpkg_ns_a/setup.py     | 10 ------
 .../typedpkg_ns_b-stubs/pyproject.toml        | 11 +++++++
 .../packages/typedpkg_ns_b-stubs/setup.py     | 14 --------
 .../packages/typedpkg_ns_b/pyproject.toml     |  8 +++++
 test-data/packages/typedpkg_ns_b/setup.py     | 10 ------
 test-data/unit/pep561.test                    | 18 -----------
 12 files changed, 64 insertions(+), 97 deletions(-)
 create mode 100644 test-data/packages/typedpkg-stubs/pyproject.toml
 delete mode 100644 test-data/packages/typedpkg-stubs/setup.py
 create mode 100644 test-data/packages/typedpkg/pyproject.toml
 delete mode 100644 test-data/packages/typedpkg/setup.py
 create mode 100644 test-data/packages/typedpkg_ns_a/pyproject.toml
 delete mode 100644 test-data/packages/typedpkg_ns_a/setup.py
 create mode 100644 test-data/packages/typedpkg_ns_b-stubs/pyproject.toml
 delete mode 100644 test-data/packages/typedpkg_ns_b-stubs/setup.py
 create mode 100644 test-data/packages/typedpkg_ns_b/pyproject.toml
 delete mode 100644 test-data/packages/typedpkg_ns_b/setup.py

diff --git a/mypy/test/testpep561.py b/mypy/test/testpep561.py
index ed8674e8d5bb0..b8a11d7fc8afd 100644
--- a/mypy/test/testpep561.py
+++ b/mypy/test/testpep561.py
@@ -47,22 +47,16 @@ def virtualenv(python_executable: str = sys.executable) -> Iterator[tuple[str, s
 
 
 def install_package(
-    pkg: str, python_executable: str = sys.executable, use_pip: bool = True, editable: bool = False
+    pkg: str, python_executable: str = sys.executable, editable: bool = False
 ) -> None:
     """Install a package from test-data/packages/pkg/"""
     working_dir = os.path.join(package_path, pkg)
     with tempfile.TemporaryDirectory() as dir:
-        if use_pip:
-            install_cmd = [python_executable, "-m", "pip", "install"]
-            if editable:
-                install_cmd.append("-e")
-            install_cmd.append(".")
-        else:
-            install_cmd = [python_executable, "setup.py"]
-            if editable:
-                install_cmd.append("develop")
-            else:
-                install_cmd.append("install")
+        install_cmd = [python_executable, "-m", "pip", "install"]
+        if editable:
+            install_cmd.append("-e")
+        install_cmd.append(".")
+
         # Note that newer versions of pip (21.3+) don't
         # follow this env variable, but this is for compatibility
         env = {"PIP_BUILD": dir}
@@ -82,21 +76,25 @@ def test_pep561(testcase: DataDrivenTestCase) -> None:
     assert testcase.old_cwd is not None, "test was not properly set up"
     python = sys.executable
 
+    if sys.version_info < (3, 8) and testcase.location[-1] == "testTypedPkgSimpleEditable":
+        # Python 3.7 doesn't ship with new enough pip to support PEP 660
+        # This is a quick hack to skip the test; we'll drop Python 3.7 support soon enough
+        return
+
     assert python is not None, "Should be impossible"
     pkgs, pip_args = parse_pkgs(testcase.input[0])
     mypy_args = parse_mypy_args(testcase.input[1])
-    use_pip = True
     editable = False
     for arg in pip_args:
-        if arg == "no-pip":
-            use_pip = False
-        elif arg == "editable":
+        if arg == "editable":
             editable = True
+        else:
+            raise ValueError(f"Unknown pip argument: {arg}")
     assert pkgs, "No packages to install for PEP 561 test?"
     with virtualenv(python) as venv:
         venv_dir, python_executable = venv
         for pkg in pkgs:
-            install_package(pkg, python_executable, use_pip, editable)
+            install_package(pkg, python_executable, editable)
 
         cmd_line = list(mypy_args)
         has_program = not ("-p" in cmd_line or "--package" in cmd_line)
diff --git a/test-data/packages/typedpkg-stubs/pyproject.toml b/test-data/packages/typedpkg-stubs/pyproject.toml
new file mode 100644
index 0000000000000..125816151ef8f
--- /dev/null
+++ b/test-data/packages/typedpkg-stubs/pyproject.toml
@@ -0,0 +1,11 @@
+[project]
+name = 'typedpkg-stubs'
+version = '0.1'
+description = 'test'
+
+[tool.hatch.build]
+include = ["**/*.pyi"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
diff --git a/test-data/packages/typedpkg-stubs/setup.py b/test-data/packages/typedpkg-stubs/setup.py
deleted file mode 100644
index 4948dc6a01df8..0000000000000
--- a/test-data/packages/typedpkg-stubs/setup.py
+++ /dev/null
@@ -1,13 +0,0 @@
-"""
-This setup file installs packages to test mypy's PEP 561 implementation
-"""
-
-from setuptools import setup
-
-setup(
-    name='typedpkg-stubs',
-    author="The mypy team",
-    version='0.1',
-    package_data={'typedpkg-stubs': ['sample.pyi', '__init__.pyi', 'py.typed']},
-    packages=['typedpkg-stubs'],
-)
diff --git a/test-data/packages/typedpkg/pyproject.toml b/test-data/packages/typedpkg/pyproject.toml
new file mode 100644
index 0000000000000..5269c94320e10
--- /dev/null
+++ b/test-data/packages/typedpkg/pyproject.toml
@@ -0,0 +1,8 @@
+[project]
+name = 'typedpkg'
+version = '0.1'
+description = 'test'
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
diff --git a/test-data/packages/typedpkg/setup.py b/test-data/packages/typedpkg/setup.py
deleted file mode 100644
index 11bcfb11a1048..0000000000000
--- a/test-data/packages/typedpkg/setup.py
+++ /dev/null
@@ -1,15 +0,0 @@
-"""
-This setup file installs packages to test mypy's PEP 561 implementation
-"""
-
-from setuptools import setup
-
-setup(
-    name='typedpkg',
-    author="The mypy team",
-    version='0.1',
-    package_data={'typedpkg': ['py.typed']},
-    packages=['typedpkg', 'typedpkg.pkg'],
-    include_package_data=True,
-    zip_safe=False,
-)
diff --git a/test-data/packages/typedpkg_ns_a/pyproject.toml b/test-data/packages/typedpkg_ns_a/pyproject.toml
new file mode 100644
index 0000000000000..cc464af75b178
--- /dev/null
+++ b/test-data/packages/typedpkg_ns_a/pyproject.toml
@@ -0,0 +1,11 @@
+[project]
+name = 'typedpkg_namespace.alpha'
+version = '0.1'
+description = 'test'
+
+[tool.hatch.build]
+include = ["**/*.py", "**/*.pyi", "**/py.typed"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
diff --git a/test-data/packages/typedpkg_ns_a/setup.py b/test-data/packages/typedpkg_ns_a/setup.py
deleted file mode 100644
index 3dab731cada93..0000000000000
--- a/test-data/packages/typedpkg_ns_a/setup.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from setuptools import setup
-
-setup(
-    name='typedpkg_namespace.alpha',
-    version='1.0.0',
-    namespace_packages=['typedpkg_ns'],
-    zip_safe=False,
-    package_data={'typedpkg_ns.a': ['py.typed']},
-    packages=['typedpkg_ns.a'],
-)
diff --git a/test-data/packages/typedpkg_ns_b-stubs/pyproject.toml b/test-data/packages/typedpkg_ns_b-stubs/pyproject.toml
new file mode 100644
index 0000000000000..d5275d1ed8b3f
--- /dev/null
+++ b/test-data/packages/typedpkg_ns_b-stubs/pyproject.toml
@@ -0,0 +1,11 @@
+[project]
+name = 'typedpkg_ns-stubs'
+version = '0.1'
+description = 'test'
+
+[tool.hatch.build]
+include = ["**/*.pyi"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
diff --git a/test-data/packages/typedpkg_ns_b-stubs/setup.py b/test-data/packages/typedpkg_ns_b-stubs/setup.py
deleted file mode 100644
index a5d7df83eeea6..0000000000000
--- a/test-data/packages/typedpkg_ns_b-stubs/setup.py
+++ /dev/null
@@ -1,14 +0,0 @@
-"""
-This setup file installs packages to test mypy's PEP 561 implementation
-"""
-
-from distutils.core import setup
-
-setup(
-    name='typedpkg_ns_b-stubs',
-    author="The mypy team",
-    version='0.1',
-    namespace_packages=['typedpkg_ns-stubs'],
-    package_data={'typedpkg_ns-stubs.b': ['__init__.pyi', 'bbb.pyi']},
-    packages=['typedpkg_ns-stubs.b'],
-)
diff --git a/test-data/packages/typedpkg_ns_b/pyproject.toml b/test-data/packages/typedpkg_ns_b/pyproject.toml
new file mode 100644
index 0000000000000..8567af11152ed
--- /dev/null
+++ b/test-data/packages/typedpkg_ns_b/pyproject.toml
@@ -0,0 +1,8 @@
+[project]
+name = 'typedpkg_namespace.beta'
+version = '0.1'
+description = 'test'
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
diff --git a/test-data/packages/typedpkg_ns_b/setup.py b/test-data/packages/typedpkg_ns_b/setup.py
deleted file mode 100644
index 4f0d0d954a735..0000000000000
--- a/test-data/packages/typedpkg_ns_b/setup.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from setuptools import setup
-
-setup(
-    name='typedpkg_namespace.beta',
-    version='1.0.0',
-    namespace_packages=['typedpkg_ns'],
-    zip_safe=False,
-    package_data={'typedpkg_ns.b': []},
-    packages=['typedpkg_ns.b'],
-)
diff --git a/test-data/unit/pep561.test b/test-data/unit/pep561.test
index 8c401cfc3c513..e8ebbd03dca7b 100644
--- a/test-data/unit/pep561.test
+++ b/test-data/unit/pep561.test
@@ -72,15 +72,6 @@ reveal_type(a)
 [out]
 testStubPrecedence.py:5: note: Revealed type is "builtins.list[builtins.str]"
 
-[case testTypedPkgSimpleEgg]
-# pkgs: typedpkg; no-pip
-from typedpkg.sample import ex
-from typedpkg import dne
-a = ex([''])
-reveal_type(a)
-[out]
-testTypedPkgSimpleEgg.py:5: note: Revealed type is "builtins.tuple[builtins.str, ...]"
-
 [case testTypedPkgSimpleEditable]
 # pkgs: typedpkg; editable
 from typedpkg.sample import ex
@@ -90,15 +81,6 @@ reveal_type(a)
 [out]
 testTypedPkgSimpleEditable.py:5: note: Revealed type is "builtins.tuple[builtins.str, ...]"
 
-[case testTypedPkgSimpleEditableEgg]
-# pkgs: typedpkg; editable; no-pip
-from typedpkg.sample import ex
-from typedpkg import dne
-a = ex([''])
-reveal_type(a)
-[out]
-testTypedPkgSimpleEditableEgg.py:5: note: Revealed type is "builtins.tuple[builtins.str, ...]"
-
 [case testTypedPkgNamespaceImportFrom]
 # pkgs: typedpkg, typedpkg_ns_a
 from typedpkg.pkg.aaa import af

From 21cc1c74b7b531ef6e1024d35b364fe30077117b Mon Sep 17 00:00:00 2001
From: Alex Waygood <Alex.Waygood@Gmail.com>
Date: Fri, 16 Jun 2023 21:24:34 +0100
Subject: [PATCH 043/129] Improve handling of attribute access on class objects
 (#14988)

Fixes #14056

#14056 was originally reported as a mypyc issue (because that's how it
presented itself to the user), but the underlying bug is really a bug to
do with how mypy understands metaclasses. On mypy `master`:

```py
class Meta(type):
    bar: str

class Foo(metaclass=Meta):
    bar: int

reveal_type(Foo().bar)  # Revealed type is int (correct!)
reveal_type(Foo.bar)  # Revealed type is int, but should be str
```

This PR fixes that incorrect behaviour.

Since this is really a mypy bug rather than a mypyc bug, I haven't added
a mypyc test, but I'm happy to if that would be useful. (I'll need some
guidance as to exactly where it should go -- I don't know much about
mypyc internals!)
---
 mypy/checkmember.py                        | 30 +++++++++++++++++---
 test-data/unit/check-class-namedtuple.test |  5 +++-
 test-data/unit/check-classes.test          | 33 ++++++++++++++++++++++
 test-data/unit/pythoneval.test             | 13 +++++++++
 4 files changed, 76 insertions(+), 5 deletions(-)

diff --git a/mypy/checkmember.py b/mypy/checkmember.py
index c2c6b3555805f..7af61a532b7b0 100644
--- a/mypy/checkmember.py
+++ b/mypy/checkmember.py
@@ -388,7 +388,7 @@ def analyze_type_callable_member_access(name: str, typ: FunctionLike, mx: Member
             # See https://github.com/python/mypy/pull/1787 for more info.
             # TODO: do not rely on same type variables being present in all constructor overloads.
             result = analyze_class_attribute_access(
-                ret_type, name, mx, original_vars=typ.items[0].variables
+                ret_type, name, mx, original_vars=typ.items[0].variables, mcs_fallback=typ.fallback
             )
             if result:
                 return result
@@ -434,17 +434,21 @@ def analyze_type_type_member_access(
         if isinstance(typ.item.item, Instance):
             item = typ.item.item.type.metaclass_type
     ignore_messages = False
+
+    if item is not None:
+        fallback = item.type.metaclass_type or fallback
+
     if item and not mx.is_operator:
         # See comment above for why operators are skipped
-        result = analyze_class_attribute_access(item, name, mx, override_info)
+        result = analyze_class_attribute_access(
+            item, name, mx, mcs_fallback=fallback, override_info=override_info
+        )
         if result:
             if not (isinstance(get_proper_type(result), AnyType) and item.type.fallback_to_any):
                 return result
             else:
                 # We don't want errors on metaclass lookup for classes with Any fallback
                 ignore_messages = True
-    if item is not None:
-        fallback = item.type.metaclass_type or fallback
 
     with mx.msg.filter_errors(filter_errors=ignore_messages):
         return _analyze_member_access(name, fallback, mx, override_info)
@@ -893,6 +897,8 @@ def analyze_class_attribute_access(
     itype: Instance,
     name: str,
     mx: MemberContext,
+    *,
+    mcs_fallback: Instance,
     override_info: TypeInfo | None = None,
     original_vars: Sequence[TypeVarLikeType] | None = None,
 ) -> Type | None:
@@ -919,6 +925,22 @@ def analyze_class_attribute_access(
             return apply_class_attr_hook(mx, hook, AnyType(TypeOfAny.special_form))
         return None
 
+    if (
+        isinstance(node.node, Var)
+        and not node.node.is_classvar
+        and not hook
+        and mcs_fallback.type.get(name)
+    ):
+        # If the same attribute is declared on the metaclass and the class but with different types,
+        # and the attribute on the class is not a ClassVar,
+        # the type of the attribute on the metaclass should take priority
+        # over the type of the attribute on the class,
+        # when the attribute is being accessed from the class object itself.
+        #
+        # Return `None` here to signify that the name should be looked up
+        # on the class object itself rather than the instance.
+        return None
+
     is_decorated = isinstance(node.node, Decorator)
     is_method = is_decorated or isinstance(node.node, FuncBase)
     if mx.is_lvalue:
diff --git a/test-data/unit/check-class-namedtuple.test b/test-data/unit/check-class-namedtuple.test
index 8ae7f6555f9db..ab2f5f3f6b48d 100644
--- a/test-data/unit/check-class-namedtuple.test
+++ b/test-data/unit/check-class-namedtuple.test
@@ -325,7 +325,10 @@ class X(NamedTuple):
 reveal_type(X._fields)  # N: Revealed type is "Tuple[builtins.str, builtins.str]"
 reveal_type(X._field_types)  # N: Revealed type is "builtins.dict[builtins.str, Any]"
 reveal_type(X._field_defaults)  # N: Revealed type is "builtins.dict[builtins.str, Any]"
-reveal_type(X.__annotations__)  # N: Revealed type is "builtins.dict[builtins.str, Any]"
+
+# In typeshed's stub for builtins.pyi, __annotations__ is `dict[str, Any]`,
+# but it's inferred as `Mapping[str, object]` here due to the fixture we're using
+reveal_type(X.__annotations__)  # N: Revealed type is "typing.Mapping[builtins.str, builtins.object]"
 
 [builtins fixtures/dict.pyi]
 
diff --git a/test-data/unit/check-classes.test b/test-data/unit/check-classes.test
index cfd0cc3a4ec64..2c80eb7b49bc6 100644
--- a/test-data/unit/check-classes.test
+++ b/test-data/unit/check-classes.test
@@ -4540,6 +4540,39 @@ def f(TA: Type[A]):
     reveal_type(TA)  # N: Revealed type is "Type[__main__.A]"
     reveal_type(TA.x)  # N: Revealed type is "builtins.int"
 
+[case testMetaclassConflictingInstanceVars]
+from typing import ClassVar
+
+class Meta(type):
+    foo: int
+    bar: int
+    eggs: ClassVar[int] = 42
+    spam: ClassVar[int] = 42
+
+class Foo(metaclass=Meta):
+    foo: str
+    bar: ClassVar[str] = 'bar'
+    eggs: str
+    spam: ClassVar[str] = 'spam'
+
+reveal_type(Foo.foo)  # N: Revealed type is "builtins.int"
+reveal_type(Foo.bar)  # N: Revealed type is "builtins.str"
+reveal_type(Foo.eggs)  # N: Revealed type is "builtins.int"
+reveal_type(Foo.spam)  # N: Revealed type is "builtins.str"
+
+class MetaSub(Meta): ...
+
+class Bar(metaclass=MetaSub):
+    foo: str
+    bar: ClassVar[str] = 'bar'
+    eggs: str
+    spam: ClassVar[str] = 'spam'
+
+reveal_type(Bar.foo)  # N: Revealed type is "builtins.int"
+reveal_type(Bar.bar)  # N: Revealed type is "builtins.str"
+reveal_type(Bar.eggs)  # N: Revealed type is "builtins.int"
+reveal_type(Bar.spam)  # N: Revealed type is "builtins.str"
+
 [case testSubclassMetaclass]
 class M1(type):
     x = 0
diff --git a/test-data/unit/pythoneval.test b/test-data/unit/pythoneval.test
index 7108734102d12..93ff2da9f7b97 100644
--- a/test-data/unit/pythoneval.test
+++ b/test-data/unit/pythoneval.test
@@ -1987,6 +1987,19 @@ def good9(foo1: Foo[Concatenate[int, P]], foo2: Foo[[int, str, bytes]], *args: P
 [out]
 _testStrictEqualitywithParamSpec.py:11: error: Non-overlapping equality check (left operand type: "Foo[[int]]", right operand type: "Bar[[int]]")
 
+[case testInferenceOfDunderDictOnClassObjects]
+class Foo: ...
+reveal_type(Foo.__dict__)
+reveal_type(Foo().__dict__)
+Foo.__dict__ = {}
+Foo().__dict__ = {}
+
+[out]
+_testInferenceOfDunderDictOnClassObjects.py:2: note: Revealed type is "types.MappingProxyType[builtins.str, Any]"
+_testInferenceOfDunderDictOnClassObjects.py:3: note: Revealed type is "builtins.dict[builtins.str, Any]"
+_testInferenceOfDunderDictOnClassObjects.py:4: error: Property "__dict__" defined in "type" is read-only
+_testInferenceOfDunderDictOnClassObjects.py:4: error: Incompatible types in assignment (expression has type "Dict[<nothing>, <nothing>]", variable has type "MappingProxyType[str, Any]")
+
 [case testTypeVarTuple]
 # flags: --enable-incomplete-feature=TypeVarTuple --enable-incomplete-feature=Unpack --python-version=3.11
 from typing import Any, Callable, Unpack, TypeVarTuple

From 6f2bfff521e708f015af1eec5118db4600b829be Mon Sep 17 00:00:00 2001
From: Ilya Priven <ilya.konstantinov@gmail.com>
Date: Sat, 17 Jun 2023 09:02:36 -0400
Subject: [PATCH 044/129] Add signature for dataclasses.replace (#14849)

Validate `dataclassses.replace` actual arguments to match the fields:

- Unlike `__init__`, the arguments are always named.
- All arguments are optional except for `InitVar`s without a default
value.

The tricks:
- We're looking up type of the first positional argument ("obj") through
private API. See #10216, #14845.
- We're preparing the signature of "replace" (for that specific
dataclass) during the dataclass transformation and storing it in a
"private" class attribute `__mypy-replace` (obviously not part of
PEP-557 but contains a hyphen so should not conflict with any future
valid identifier). Stashing the signature into the symbol table allows
it to be passed across phases and cached across invocations. The stashed
signature lacks the first argument, which we prepend at function
signature hook time, since it depends on the type that `replace` is
called on.

Based on #14526 but actually simpler.
Partially addresses #5152.

# Remaining tasks

- [x] handle generic dataclasses
- [x] avoid data class transforms
- [x] fine-grained mode tests

---------

Co-authored-by: Alex Waygood <Alex.Waygood@Gmail.com>
---
 mypy/plugins/dataclasses.py                   | 163 +++++++++++++++++-
 mypy/plugins/default.py                       |   4 +-
 test-data/unit/check-dataclass-transform.test |  19 ++
 test-data/unit/check-dataclasses.test         | 157 ++++++++++++++++-
 test-data/unit/deps.test                      |   2 +
 test-data/unit/fine-grained-dataclass.test    |  25 +++
 test-data/unit/lib-stub/dataclasses.pyi       |   2 +
 test-data/unit/pythoneval.test                |  20 +++
 8 files changed, 389 insertions(+), 3 deletions(-)
 create mode 100644 test-data/unit/fine-grained-dataclass.test

diff --git a/mypy/plugins/dataclasses.py b/mypy/plugins/dataclasses.py
index 2fd903f2f8b98..913b1ef233120 100644
--- a/mypy/plugins/dataclasses.py
+++ b/mypy/plugins/dataclasses.py
@@ -7,6 +7,8 @@
 
 from mypy import errorcodes, message_registry
 from mypy.expandtype import expand_type, expand_type_by_instance
+from mypy.meet import meet_types
+from mypy.messages import format_type_bare
 from mypy.nodes import (
     ARG_NAMED,
     ARG_NAMED_OPT,
@@ -38,7 +40,7 @@
     TypeVarExpr,
     Var,
 )
-from mypy.plugin import ClassDefContext, SemanticAnalyzerPluginInterface
+from mypy.plugin import ClassDefContext, FunctionSigContext, SemanticAnalyzerPluginInterface
 from mypy.plugins.common import (
     _get_callee_type,
     _get_decorator_bool_argument,
@@ -56,10 +58,13 @@
     Instance,
     LiteralType,
     NoneType,
+    ProperType,
     TupleType,
     Type,
     TypeOfAny,
     TypeVarType,
+    UninhabitedType,
+    UnionType,
     get_proper_type,
 )
 from mypy.typevars import fill_typevars
@@ -76,6 +81,7 @@
     frozen_default=False,
     field_specifiers=("dataclasses.Field", "dataclasses.field"),
 )
+_INTERNAL_REPLACE_SYM_NAME = "__mypy-replace"
 
 
 class DataclassAttribute:
@@ -344,6 +350,9 @@ def transform(self) -> bool:
 
         self._add_dataclass_fields_magic_attribute()
 
+        if self._spec is _TRANSFORM_SPEC_FOR_DATACLASSES:
+            self._add_internal_replace_method(attributes)
+
         info.metadata["dataclass"] = {
             "attributes": [attr.serialize() for attr in attributes],
             "frozen": decorator_arguments["frozen"],
@@ -351,6 +360,37 @@ def transform(self) -> bool:
 
         return True
 
+    def _add_internal_replace_method(self, attributes: list[DataclassAttribute]) -> None:
+        """
+        Stashes the signature of 'dataclasses.replace(...)' for this specific dataclass
+        to be used later whenever 'dataclasses.replace' is called for this dataclass.
+        """
+        arg_types: list[Type] = []
+        arg_kinds = []
+        arg_names: list[str | None] = []
+
+        info = self._cls.info
+        for attr in attributes:
+            attr_type = attr.expand_type(info)
+            assert attr_type is not None
+            arg_types.append(attr_type)
+            arg_kinds.append(
+                ARG_NAMED if attr.is_init_var and not attr.has_default else ARG_NAMED_OPT
+            )
+            arg_names.append(attr.name)
+
+        signature = CallableType(
+            arg_types=arg_types,
+            arg_kinds=arg_kinds,
+            arg_names=arg_names,
+            ret_type=NoneType(),
+            fallback=self._api.named_type("builtins.function"),
+        )
+
+        self._cls.info.names[_INTERNAL_REPLACE_SYM_NAME] = SymbolTableNode(
+            kind=MDEF, node=FuncDef(typ=signature), plugin_generated=True
+        )
+
     def add_slots(
         self, info: TypeInfo, attributes: list[DataclassAttribute], *, correct_version: bool
     ) -> None:
@@ -893,3 +933,124 @@ def _has_direct_dataclass_transform_metaclass(info: TypeInfo) -> bool:
         info.declared_metaclass is not None
         and info.declared_metaclass.type.dataclass_transform_spec is not None
     )
+
+
+def _fail_not_dataclass(ctx: FunctionSigContext, t: Type, parent_t: Type) -> None:
+    t_name = format_type_bare(t, ctx.api.options)
+    if parent_t is t:
+        msg = (
+            f'Argument 1 to "replace" has a variable type "{t_name}" not bound to a dataclass'
+            if isinstance(t, TypeVarType)
+            else f'Argument 1 to "replace" has incompatible type "{t_name}"; expected a dataclass'
+        )
+    else:
+        pt_name = format_type_bare(parent_t, ctx.api.options)
+        msg = (
+            f'Argument 1 to "replace" has type "{pt_name}" whose item "{t_name}" is not bound to a dataclass'
+            if isinstance(t, TypeVarType)
+            else f'Argument 1 to "replace" has incompatible type "{pt_name}" whose item "{t_name}" is not a dataclass'
+        )
+
+    ctx.api.fail(msg, ctx.context)
+
+
+def _get_expanded_dataclasses_fields(
+    ctx: FunctionSigContext, typ: ProperType, display_typ: ProperType, parent_typ: ProperType
+) -> list[CallableType] | None:
+    """
+    For a given type, determine what dataclasses it can be: for each class, return the field types.
+    For generic classes, the field types are expanded.
+    If the type contains Any or a non-dataclass, returns None; in the latter case, also reports an error.
+    """
+    if isinstance(typ, AnyType):
+        return None
+    elif isinstance(typ, UnionType):
+        ret: list[CallableType] | None = []
+        for item in typ.relevant_items():
+            item = get_proper_type(item)
+            item_types = _get_expanded_dataclasses_fields(ctx, item, item, parent_typ)
+            if ret is not None and item_types is not None:
+                ret += item_types
+            else:
+                ret = None  # but keep iterating to emit all errors
+        return ret
+    elif isinstance(typ, TypeVarType):
+        return _get_expanded_dataclasses_fields(
+            ctx, get_proper_type(typ.upper_bound), display_typ, parent_typ
+        )
+    elif isinstance(typ, Instance):
+        replace_sym = typ.type.get_method(_INTERNAL_REPLACE_SYM_NAME)
+        if replace_sym is None:
+            _fail_not_dataclass(ctx, display_typ, parent_typ)
+            return None
+        replace_sig = replace_sym.type
+        assert isinstance(replace_sig, ProperType)
+        assert isinstance(replace_sig, CallableType)
+        return [expand_type_by_instance(replace_sig, typ)]
+    else:
+        _fail_not_dataclass(ctx, display_typ, parent_typ)
+        return None
+
+
+# TODO: we can potentially get the function signature hook to allow returning a union
+#  and leave this to the regular machinery of resolving a union of callables
+#  (https://github.com/python/mypy/issues/15457)
+def _meet_replace_sigs(sigs: list[CallableType]) -> CallableType:
+    """
+    Produces the lowest bound of the 'replace' signatures of multiple dataclasses.
+    """
+    args = {
+        name: (typ, kind)
+        for name, typ, kind in zip(sigs[0].arg_names, sigs[0].arg_types, sigs[0].arg_kinds)
+    }
+
+    for sig in sigs[1:]:
+        sig_args = {
+            name: (typ, kind)
+            for name, typ, kind in zip(sig.arg_names, sig.arg_types, sig.arg_kinds)
+        }
+        for name in (*args.keys(), *sig_args.keys()):
+            sig_typ, sig_kind = args.get(name, (UninhabitedType(), ARG_NAMED_OPT))
+            sig2_typ, sig2_kind = sig_args.get(name, (UninhabitedType(), ARG_NAMED_OPT))
+            args[name] = (
+                meet_types(sig_typ, sig2_typ),
+                ARG_NAMED_OPT if sig_kind == sig2_kind == ARG_NAMED_OPT else ARG_NAMED,
+            )
+
+    return sigs[0].copy_modified(
+        arg_names=list(args.keys()),
+        arg_types=[typ for typ, _ in args.values()],
+        arg_kinds=[kind for _, kind in args.values()],
+    )
+
+
+def replace_function_sig_callback(ctx: FunctionSigContext) -> CallableType:
+    """
+    Returns a signature for the 'dataclasses.replace' function that's dependent on the type
+    of the first positional argument.
+    """
+    if len(ctx.args) != 2:
+        # Ideally the name and context should be callee's, but we don't have it in FunctionSigContext.
+        ctx.api.fail(f'"{ctx.default_signature.name}" has unexpected type annotation', ctx.context)
+        return ctx.default_signature
+
+    if len(ctx.args[0]) != 1:
+        return ctx.default_signature  # leave it to the type checker to complain
+
+    obj_arg = ctx.args[0][0]
+    obj_type = get_proper_type(ctx.api.get_expression_type(obj_arg))
+    inst_type_str = format_type_bare(obj_type, ctx.api.options)
+
+    replace_sigs = _get_expanded_dataclasses_fields(ctx, obj_type, obj_type, obj_type)
+    if replace_sigs is None:
+        return ctx.default_signature
+    replace_sig = _meet_replace_sigs(replace_sigs)
+
+    return replace_sig.copy_modified(
+        arg_names=[None, *replace_sig.arg_names],
+        arg_kinds=[ARG_POS, *replace_sig.arg_kinds],
+        arg_types=[obj_type, *replace_sig.arg_types],
+        ret_type=obj_type,
+        fallback=ctx.default_signature.fallback,
+        name=f"{ctx.default_signature.name} of {inst_type_str}",
+    )
diff --git a/mypy/plugins/default.py b/mypy/plugins/default.py
index 500eef76a9d98..b83c0192a14b7 100644
--- a/mypy/plugins/default.py
+++ b/mypy/plugins/default.py
@@ -51,12 +51,14 @@ def get_function_hook(self, fullname: str) -> Callable[[FunctionContext], Type]
     def get_function_signature_hook(
         self, fullname: str
     ) -> Callable[[FunctionSigContext], FunctionLike] | None:
-        from mypy.plugins import attrs
+        from mypy.plugins import attrs, dataclasses
 
         if fullname in ("attr.evolve", "attrs.evolve", "attr.assoc", "attrs.assoc"):
             return attrs.evolve_function_sig_callback
         elif fullname in ("attr.fields", "attrs.fields"):
             return attrs.fields_function_sig_callback
+        elif fullname == "dataclasses.replace":
+            return dataclasses.replace_function_sig_callback
         return None
 
     def get_method_signature_hook(
diff --git a/test-data/unit/check-dataclass-transform.test b/test-data/unit/check-dataclass-transform.test
index be6b46d708469..53a6eea95bfa1 100644
--- a/test-data/unit/check-dataclass-transform.test
+++ b/test-data/unit/check-dataclass-transform.test
@@ -840,6 +840,24 @@ reveal_type(bar.base)  # N: Revealed type is "builtins.int"
 [typing fixtures/typing-full.pyi]
 [builtins fixtures/dataclasses.pyi]
 
+[case testDataclassTransformReplace]
+from dataclasses import replace
+from typing import dataclass_transform, Type
+
+@dataclass_transform()
+def my_dataclass(cls: Type) -> Type:
+    return cls
+
+@my_dataclass
+class Person:
+    name: str
+
+p = Person('John')
+y = replace(p, name='Bob')  # E: Argument 1 to "replace" has incompatible type "Person"; expected a dataclass
+
+[typing fixtures/typing-full.pyi]
+[builtins fixtures/dataclasses.pyi]
+
 [case testDataclassTransformSimpleDescriptor]
 # flags: --python-version 3.11
 
@@ -1051,5 +1069,6 @@ class Desc2:
 class C:
     x: Desc  # E: Unsupported signature for "__set__" in "Desc"
     y: Desc2  # E: Unsupported "__set__" in "Desc2"
+
 [typing fixtures/typing-full.pyi]
 [builtins fixtures/dataclasses.pyi]
diff --git a/test-data/unit/check-dataclasses.test b/test-data/unit/check-dataclasses.test
index 914e1c2e06028..1f6c8d1432439 100644
--- a/test-data/unit/check-dataclasses.test
+++ b/test-data/unit/check-dataclasses.test
@@ -2006,7 +2006,6 @@ e: Element[Bar]
 reveal_type(e.elements)  # N: Revealed type is "typing.Sequence[__main__.Element[__main__.Bar]]"
 [builtins fixtures/dataclasses.pyi]
 
-
 [case testIfConditionsInDefinition]
 # flags: --python-version 3.11 --always-true TRUTH
 from dataclasses import dataclass
@@ -2040,8 +2039,164 @@ Foo(
     present_4=4,
     present_5=5,
 )
+
+[builtins fixtures/dataclasses.pyi]
+
+[case testReplace]
+from dataclasses import dataclass, replace, InitVar
+from typing import ClassVar
+
+@dataclass
+class A:
+    x: int
+    q: InitVar[int]
+    q2: InitVar[int] = 0
+    c: ClassVar[int]
+
+
+a = A(x=42, q=7)
+a2 = replace(a)  # E: Missing named argument "q" for "replace" of "A"
+a2 = replace(a, q=42)
+a2 = replace(a, x=42, q=42)
+a2 = replace(a, x=42, q=42, c=7)  # E: Unexpected keyword argument "c" for "replace" of "A"
+a2 = replace(a, x='42', q=42)  # E: Argument "x" to "replace" of "A" has incompatible type "str"; expected "int"
+a2 = replace(a, q='42')  # E: Argument "q" to "replace" of "A" has incompatible type "str"; expected "int"
+reveal_type(a2)  # N: Revealed type is "__main__.A"
+
+[case testReplaceUnion]
+# flags: --strict-optional
+from typing import Generic, Union, TypeVar
+from dataclasses import dataclass, replace, InitVar
+
+T = TypeVar('T')
+
+@dataclass
+class A(Generic[T]):
+    x: T  # exercises meet(T=int, int) = int
+    y: bool  # exercises meet(bool, int) = bool
+    z: str  # exercises meet(str, bytes) = <nothing>
+    w: dict  # exercises meet(dict, <nothing>) = <nothing>
+    init_var: InitVar[int]  # exercises (non-optional, optional) = non-optional
+
+@dataclass
+class B:
+    x: int
+    y: int
+    z: bytes
+    init_var: int
+
+
+a_or_b: Union[A[int], B]
+_ = replace(a_or_b, x=42, y=True, init_var=42)
+_ = replace(a_or_b, x=42, y=True)  # E: Missing named argument "init_var" for "replace" of "Union[A[int], B]"
+_ = replace(a_or_b, x=42, y=True, z='42', init_var=42)  # E: Argument "z" to "replace" of "Union[A[int], B]" has incompatible type "str"; expected <nothing>
+_ = replace(a_or_b, x=42, y=True, w={}, init_var=42)  # E: Argument "w" to "replace" of "Union[A[int], B]" has incompatible type "Dict[<nothing>, <nothing>]"; expected <nothing>
+_ = replace(a_or_b, y=42, init_var=42)  # E: Argument "y" to "replace" of "Union[A[int], B]" has incompatible type "int"; expected "bool"
+
 [builtins fixtures/dataclasses.pyi]
 
+[case testReplaceUnionOfTypeVar]
+# flags: --strict-optional
+from typing import Generic, Union, TypeVar
+from dataclasses import dataclass, replace
+
+@dataclass
+class A:
+    x: int
+    y: int
+    z: str
+    w: dict
+
+class B:
+    pass
+
+TA = TypeVar('TA', bound=A)
+TB = TypeVar('TB', bound=B)
+
+def f(b_or_t: Union[TA, TB, int]) -> None:
+    a2 = replace(b_or_t)   # E: Argument 1 to "replace" has type "Union[TA, TB, int]" whose item "TB" is not bound to a dataclass  # E: Argument 1 to "replace" has incompatible type "Union[TA, TB, int]" whose item "int" is not a dataclass
+
+[case testReplaceTypeVarBoundNotDataclass]
+from dataclasses import dataclass, replace
+from typing import Union, TypeVar
+
+TInt = TypeVar('TInt', bound=int)
+TAny = TypeVar('TAny')
+TNone = TypeVar('TNone', bound=None)
+TUnion = TypeVar('TUnion', bound=Union[str, int])
+
+def f1(t: TInt) -> None:
+    _ = replace(t, x=42)  # E: Argument 1 to "replace" has a variable type "TInt" not bound to a dataclass
+
+def f2(t: TAny) -> TAny:
+    return replace(t, x='spam')  # E: Argument 1 to "replace" has a variable type "TAny" not bound to a dataclass
+
+def f3(t: TNone) -> TNone:
+    return replace(t, x='spam')  # E: Argument 1 to "replace" has a variable type "TNone" not bound to a dataclass
+
+def f4(t: TUnion) -> TUnion:
+    return replace(t, x='spam')  # E: Argument 1 to "replace" has incompatible type "TUnion" whose item "str" is not a dataclass  # E: Argument 1 to "replace" has incompatible type "TUnion" whose item "int" is not a dataclass
+
+[case testReplaceTypeVarBound]
+from dataclasses import dataclass, replace
+from typing import TypeVar
+
+@dataclass
+class A:
+    x: int
+
+@dataclass
+class B(A):
+    pass
+
+TA = TypeVar('TA', bound=A)
+
+def f(t: TA) -> TA:
+    t2 = replace(t, x=42)
+    reveal_type(t2)  # N: Revealed type is "TA`-1"
+    _ = replace(t, x='42')  # E: Argument "x" to "replace" of "TA" has incompatible type "str"; expected "int"
+    return t2
+
+f(A(x=42))
+f(B(x=42))
+
+[case testReplaceAny]
+from dataclasses import replace
+from typing import Any
+
+a: Any
+a2 = replace(a)
+reveal_type(a2)  # N: Revealed type is "Any"
+
+[case testReplaceNotDataclass]
+from dataclasses import replace
+
+replace(5)  # E: Argument 1 to "replace" has incompatible type "int"; expected a dataclass
+
+class C:
+    pass
+
+replace(C())  # E: Argument 1 to "replace" has incompatible type "C"; expected a dataclass
+
+replace(None)  # E: Argument 1 to "replace" has incompatible type "None"; expected a dataclass
+
+[case testReplaceGeneric]
+from dataclasses import dataclass, replace, InitVar
+from typing import ClassVar, Generic, TypeVar
+
+T = TypeVar('T')
+
+@dataclass
+class A(Generic[T]):
+    x: T
+
+a = A(x=42)
+reveal_type(a)  # N: Revealed type is "__main__.A[builtins.int]"
+a2 = replace(a, x=42)
+reveal_type(a2)  # N: Revealed type is "__main__.A[builtins.int]"
+a2 = replace(a, x='42')  # E: Argument "x" to "replace" of "A[int]" has incompatible type "str"; expected "int"
+reveal_type(a2)  # N: Revealed type is "__main__.A[builtins.int]"
+
 [case testProtocolNoCrash]
 from typing import Protocol, Union, ClassVar
 from dataclasses import dataclass, field
diff --git a/test-data/unit/deps.test b/test-data/unit/deps.test
index 28d51f1a4c30b..fe5107b1529d9 100644
--- a/test-data/unit/deps.test
+++ b/test-data/unit/deps.test
@@ -1388,6 +1388,7 @@ class B(A):
 <m.A.(abstract)> -> <m.B.__init__>, m
 <m.A.__dataclass_fields__> -> <m.B.__dataclass_fields__>
 <m.A.__init__> -> <m.B.__init__>, m.B.__init__
+<m.A.__mypy-replace> -> <m.B.__mypy-replace>
 <m.A.__new__> -> <m.B.__new__>
 <m.A.x> -> <m.B.x>
 <m.A.y> -> <m.B.y>
@@ -1419,6 +1420,7 @@ class B(A):
 <m.A.__dataclass_fields__> -> <m.B.__dataclass_fields__>
 <m.A.__init__> -> <m.B.__init__>, m.B.__init__
 <m.A.__match_args__> -> <m.B.__match_args__>
+<m.A.__mypy-replace> -> <m.B.__mypy-replace>
 <m.A.__new__> -> <m.B.__new__>
 <m.A.x> -> <m.B.x>
 <m.A.y> -> <m.B.y>
diff --git a/test-data/unit/fine-grained-dataclass.test b/test-data/unit/fine-grained-dataclass.test
new file mode 100644
index 0000000000000..036d858ddf69f
--- /dev/null
+++ b/test-data/unit/fine-grained-dataclass.test
@@ -0,0 +1,25 @@
+[case testReplace]
+[file model.py]
+from dataclasses import dataclass
+
+@dataclass
+class Model:
+    x: int = 0
+[file replace.py]
+from dataclasses import replace
+from model import Model
+
+m = Model()
+replace(m, x=42)
+
+[file model.py.2]
+from dataclasses import dataclass
+
+@dataclass
+class Model:
+    x: str = 'hello'
+
+[builtins fixtures/dataclasses.pyi]
+[out]
+==
+replace.py:5: error: Argument "x" to "replace" of "Model" has incompatible type "int"; expected "str"
diff --git a/test-data/unit/lib-stub/dataclasses.pyi b/test-data/unit/lib-stub/dataclasses.pyi
index bd33b459266c1..b2b48c2ae4862 100644
--- a/test-data/unit/lib-stub/dataclasses.pyi
+++ b/test-data/unit/lib-stub/dataclasses.pyi
@@ -32,3 +32,5 @@ def field(*,
 
 
 class Field(Generic[_T]): pass
+
+def replace(__obj: _T, **changes: Any) -> _T: ...
diff --git a/test-data/unit/pythoneval.test b/test-data/unit/pythoneval.test
index 93ff2da9f7b97..8c82b6843a3bf 100644
--- a/test-data/unit/pythoneval.test
+++ b/test-data/unit/pythoneval.test
@@ -2024,3 +2024,23 @@ def foo(callback: Callable[[], Any]) -> None:
 
 def call(callback: Callable[[Unpack[Ts]], Any], *args: Unpack[Ts]) -> Any:
     ...
+
+[case testDataclassReplace]
+from dataclasses import dataclass, replace
+
+@dataclass
+class A:
+    x: int
+
+
+a = A(x=42)
+a2 = replace(a, x=42)
+reveal_type(a2)
+a2 = replace()
+a2 = replace(a, x='spam')
+a2 = replace(a, x=42, q=42)
+[out]
+_testDataclassReplace.py:10: note: Revealed type is "_testDataclassReplace.A"
+_testDataclassReplace.py:11: error: Too few arguments for "replace"
+_testDataclassReplace.py:12: error: Argument "x" to "replace" of "A" has incompatible type "str"; expected "int"
+_testDataclassReplace.py:13: error: Unexpected keyword argument "q" for "replace" of "A"

From 91b67405a7cd9da551411ccb4e28493647208c11 Mon Sep 17 00:00:00 2001
From: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
Date: Sun, 18 Jun 2023 14:12:50 -0700
Subject: [PATCH 045/129] Small improvements to protocol documentation (#15460)

---
 docs/source/protocols.rst | 50 +++++++++++++++++++--------------------
 1 file changed, 24 insertions(+), 26 deletions(-)

diff --git a/docs/source/protocols.rst b/docs/source/protocols.rst
index 95b870265f73b..3336d77cb3978 100644
--- a/docs/source/protocols.rst
+++ b/docs/source/protocols.rst
@@ -3,26 +3,24 @@
 Protocols and structural subtyping
 ==================================
 
-Mypy supports two ways of deciding whether two classes are compatible
-as types: nominal subtyping and structural subtyping.
-
-*Nominal* subtyping is strictly based on the class hierarchy. If class ``D``
-inherits class ``C``, it's also a subtype of ``C``, and instances of
-``D`` can be used when ``C`` instances are expected. This form of
-subtyping is used by default in mypy, since it's easy to understand
-and produces clear and concise error messages, and since it matches
-how the native :py:func:`isinstance <isinstance>` check works -- based on class
+The Python type system supports two ways of deciding whether two objects are
+compatible as types: nominal subtyping and structural subtyping.
+
+*Nominal* subtyping is strictly based on the class hierarchy. If class ``Dog``
+inherits class ``Animal``, it's a subtype of ``Animal``. Instances of ``Dog``
+can be used when ``Animal`` instances are expected. This form of subtyping
+subtyping is what Python's type system predominantly uses: it's easy to
+understand and produces clear and concise error messages, and matches how the
+native :py:func:`isinstance <isinstance>` check works -- based on class
 hierarchy.
 
-*Structural* subtyping is based on the operations that can be performed with an object. Class ``D`` is
-a structural subtype of class ``C`` if the former has all attributes
-and methods of the latter, and with compatible types.
+*Structural* subtyping is based on the operations that can be performed with an
+object. Class ``Dog`` is a structural subtype of class ``Animal`` if the former
+has all attributes and methods of the latter, and with compatible types.
 
-Structural subtyping can be seen as a static equivalent of duck
-typing, which is well known to Python programmers. Mypy provides
-support for structural subtyping via protocol classes described
-below.  See :pep:`544` for the detailed specification of protocols
-and structural subtyping in Python.
+Structural subtyping can be seen as a static equivalent of duck typing, which is
+well known to Python programmers. See :pep:`544` for the detailed specification
+of protocols and structural subtyping in Python.
 
 .. _predefined_protocols:
 
@@ -60,8 +58,7 @@ For example, ``IntList`` below is iterable, over ``int`` values:
 
 :ref:`predefined_protocols_reference` lists all protocols defined in
 :py:mod:`typing` and the signatures of the corresponding methods you need to define
-to implement each protocol (the signatures can be left out, as always, but mypy
-won't type check unannotated methods).
+to implement each protocol.
 
 Simple user-defined protocols
 *****************************
@@ -89,18 +86,12 @@ class:
        for item in items:
            item.close()
 
-   close_all([Resource(), open('some/file')])  # Okay!
+   close_all([Resource(), open('some/file')])  # OK
 
 ``Resource`` is a subtype of the ``SupportsClose`` protocol since it defines
 a compatible ``close`` method. Regular file objects returned by :py:func:`open` are
 similarly compatible with the protocol, as they support ``close()``.
 
-.. note::
-
-   The ``Protocol`` base class is provided in the ``typing_extensions``
-   package for Python 3.4-3.7. Starting with Python 3.8, ``Protocol``
-   is included in the ``typing`` module.
-
 Defining subprotocols and subclassing protocols
 ***********************************************
 
@@ -171,6 +162,13 @@ abstract:
    ExplicitSubclass()  # error: Cannot instantiate abstract class 'ExplicitSubclass'
                        # with abstract attributes 'attr' and 'method'
 
+Similarly, explicitly assigning to a protocol instance can be a way to ask the
+type checker to verify that your class implements a protocol:
+
+.. code-block:: python
+
+   _proto: SomeProto = cast(ExplicitSubclass, None)
+
 Invariance of protocol attributes
 *********************************
 

From 0873230ee60461110bd7bfde7ca3886878aae389 Mon Sep 17 00:00:00 2001
From: Ivan Levkivskyi <levkivskyi@gmail.com>
Date: Sun, 18 Jun 2023 23:19:29 +0100
Subject: [PATCH 046/129] Foundations for non-linear solver and polymorphic
 application (#15287)

Fixes #1317
Fixes #5738
Fixes #12919
(also fixes a `FIX` comment that is more than 10 years old according to
git blame)

Note: although this PR fixes most typical use-cases for type inference
against generic functions, it is intentionally incomplete, and it is
made in a way to limit implications to small scope.

This PR has essentially three components (better infer, better solve,
better apply - all three are needed for this MVP to work):
* A "tiny" change to `constraints.py`: if the actual function is
generic, we unify it with template before inferring constraints. This
prevents leaking generic type variables of actual in the solutions
(which makes no sense), but also introduces new kind of constraints `T
<: F[S]`, where type variables we solve for appear in target type. These
are much harder to solve, but also it is a great opportunity to play
with them to prepare for single bin inference (if we will switch to it
in some form later). Note unifying is not the best solution, but a good
first approximation (see below on what is the best solution).
* New more sophisticated constraint solver in `solve.py`. The full
algorithm is outlined in the docstring for `solve_non_linear()`. It
looks like it should be able to solve arbitrary constraints that don't
(indirectly) contain "F-bounded" things like `T <: list[T]`. Very short
the idea is to compute transitive closure, then organize constraints by
topologically sorted SCCs.
* Polymorphic type argument application in `checkexpr.py`. In cases
where solver identifies there are free variables (e.g. we have just one
constraint `S <: list[T]`, so `T` is free, and solution for `S` is
`list[T]`) it will apply the solutions while creating new generic
functions. For example, if we have a function `def [S, T] (fn:
Callable[[S], T]) -> Callable[[S], T]` applied to a function `def [U]
(x: U) -> U`, this will result in `def [T] (T) -> T` as the return.

I want to put here some thoughts on the last ingredient, since it may be
mysterious, but now it seems to me it is actually a very well defined
procedure. The key point here is thinking about generic functions as
about infinite intersections or infinite overloads. Now reducing these
infinite overloads/intersections to finite ones it is easy to understand
what is actually going on. For example, imagine we live in a world with
just two types `int` and `str`. Now we have two functions:
```python
T = TypeVar("T")
S = TypeVar("S")
U = TypeVar("U")

def dec(fn: Callable[[T], S]) -> Callable[[T], S]: ...
def id(x: U) -> U: ...
```
the first one can be seen as overload over
```
((int) -> int) -> ((int) -> int)  # 1
((int) -> str) -> ((int) -> str)  # 2
((str) -> int) -> ((str) -> int)  # 3
((str) -> str) -> ((str) -> str)  # 4
```
and second as an overload over
```
(int) -> int
(str) -> str
```
Now what happens when I apply `dec(id)`? We need to choose an overload
that matches the argument (this is what we call type inference), but
here is a trick, in this case two overloads of `dec` match the argument
type. So (and btw I think we are missing this for real overloads) we
construct a new overload that returns intersection of matching overloads
`# 1` and `# 4`. So if we generalize this intuition to the general case,
the inference is selection of an (infinite) parametrized subset among
the bigger parameterized set of intersecting types. The only question is
whether resulting infinite intersection is representable in our type
system. For example `forall T. dict[T, T]` can make sense but is not
representable, while `forall T. (T) -> T` is a well defined type. And
finally, there is a very easy way to find whether a type is
representable or not, we are already doing this during semantic
analyzis. I use the same logic (that I used to view as ad-hoc because of
lack of good syntax for callables) to bind type variables in the
inferred type.

OK, so here is the list of missing features, and some comments on them:
1. Instead of unifying the actual with template we should include
actual's variables in variable set we solve for, as explained in
https://github.com/python/mypy/issues/5738#issuecomment-511242682. Note
however, this will work only together with the next item
2. We need to (iteratively) infer secondary constraints after linear
propagation, e.g. `Sequence[T] <: S <: Sequence[U] => T <: U`
3. Support `ParamSpec` (and probably `TypeVarTuple`). Current support
for applying callables with `ParamSpec` to generics is hacky, and kind
of dead-end. Although `(Callable[P, T]) -> Callable[P, List[T]]` works
when applied to `id`, even a slight variation like `(Callable[P,
List[T]]) -> Callable[P, T]` fails. I think it needs to be re-worked in
the framework I propose (the tests I added are just to be sure I don't
break existing code)
4. Support actual types that are generic in type variables with upper
bounds or values (likely we just need to be careful when propagating
constraints and choosing free variable within an SCC).
5. Add backtracking for upper/lower bound choice. In general, in the
current "Hanoi Tower" inference scheme it is very hard to backtrack, but
in in this specific choice in the new solver, it should be totally
possible to switch from lower to upper bound on a previous step, if we
found no solution (or `<nothing>`/`object`).
6. After we polish it, we can use the new solver in more situations,
e.g. for return type context, and for unification during callable
subtyping.
7. Long term we may want to allow instances to bind type variables, at
least for things like `LRUCache[[x: T], T]`. Btw note that I apply force
expansion to type aliases and callback protocols. Since I can't
transform e.g. `A = Callable[[T], T]` into a generic callable without
getting proper type.
8. We need to figure out a solution for scenarios where non-linear
targets with free variables and constant targets mix without secondary
constraints, like `T <: List[int], T <: List[S]`.

I am planning to address at least majority of the above items, but I
think we should move slowly, since in my experience type inference is
really fragile topic with hard to predict long reaching consequences.
Please play with this PR if you want to and have time, and please
suggest tests to add.
---
 mypy/build.py                                 | 106 +----
 mypy/checkexpr.py                             | 145 ++++++-
 mypy/constraints.py                           |  25 +-
 mypy/graph_utils.py                           | 112 +++++
 mypy/infer.py                                 |   3 +-
 mypy/main.py                                  |   5 +
 mypy/options.py                               |   2 +
 mypy/semanal.py                               |   2 +-
 mypy/solve.py                                 | 401 +++++++++++++++---
 mypy/test/testgraph.py                        |  11 +-
 mypy/typeanal.py                              |  13 -
 mypy/types.py                                 |  13 +
 mypy/typestate.py                             |   6 +-
 test-data/unit/check-generics.test            | 247 +++++++++++
 .../unit/check-parameter-specification.test   |  37 ++
 test-data/unit/check-plugin-attrs.test        |   3 +-
 test-data/unit/pythoneval.test                |  60 ++-
 17 files changed, 998 insertions(+), 193 deletions(-)
 create mode 100644 mypy/graph_utils.py

diff --git a/mypy/build.py b/mypy/build.py
index 7913eae9c6ed8..2f556120d4303 100644
--- a/mypy/build.py
+++ b/mypy/build.py
@@ -31,14 +31,12 @@
     Callable,
     ClassVar,
     Dict,
-    Iterable,
     Iterator,
     Mapping,
     NamedTuple,
     NoReturn,
     Sequence,
     TextIO,
-    TypeVar,
 )
 from typing_extensions import Final, TypeAlias as _TypeAlias
 
@@ -47,6 +45,7 @@
 import mypy.semanal_main
 from mypy.checker import TypeChecker
 from mypy.errors import CompileError, ErrorInfo, Errors, report_internal_error
+from mypy.graph_utils import prepare_sccs, strongly_connected_components, topsort
 from mypy.indirection import TypeIndirectionVisitor
 from mypy.messages import MessageBuilder
 from mypy.nodes import Import, ImportAll, ImportBase, ImportFrom, MypyFile, SymbolTable, TypeInfo
@@ -3466,15 +3465,8 @@ def sorted_components(
     edges = {id: deps_filtered(graph, vertices, id, pri_max) for id in vertices}
     sccs = list(strongly_connected_components(vertices, edges))
     # Topsort.
-    sccsmap = {id: frozenset(scc) for scc in sccs for id in scc}
-    data: dict[AbstractSet[str], set[AbstractSet[str]]] = {}
-    for scc in sccs:
-        deps: set[AbstractSet[str]] = set()
-        for id in scc:
-            deps.update(sccsmap[x] for x in deps_filtered(graph, vertices, id, pri_max))
-        data[frozenset(scc)] = deps
     res = []
-    for ready in topsort(data):
+    for ready in topsort(prepare_sccs(sccs, edges)):
         # Sort the sets in ready by reversed smallest State.order.  Examples:
         #
         # - If ready is [{x}, {y}], x.order == 1, y.order == 2, we get
@@ -3499,100 +3491,6 @@ def deps_filtered(graph: Graph, vertices: AbstractSet[str], id: str, pri_max: in
     ]
 
 
-def strongly_connected_components(
-    vertices: AbstractSet[str], edges: dict[str, list[str]]
-) -> Iterator[set[str]]:
-    """Compute Strongly Connected Components of a directed graph.
-
-    Args:
-      vertices: the labels for the vertices
-      edges: for each vertex, gives the target vertices of its outgoing edges
-
-    Returns:
-      An iterator yielding strongly connected components, each
-      represented as a set of vertices.  Each input vertex will occur
-      exactly once; vertices not part of a SCC are returned as
-      singleton sets.
-
-    From https://code.activestate.com/recipes/578507/.
-    """
-    identified: set[str] = set()
-    stack: list[str] = []
-    index: dict[str, int] = {}
-    boundaries: list[int] = []
-
-    def dfs(v: str) -> Iterator[set[str]]:
-        index[v] = len(stack)
-        stack.append(v)
-        boundaries.append(index[v])
-
-        for w in edges[v]:
-            if w not in index:
-                yield from dfs(w)
-            elif w not in identified:
-                while index[w] < boundaries[-1]:
-                    boundaries.pop()
-
-        if boundaries[-1] == index[v]:
-            boundaries.pop()
-            scc = set(stack[index[v] :])
-            del stack[index[v] :]
-            identified.update(scc)
-            yield scc
-
-    for v in vertices:
-        if v not in index:
-            yield from dfs(v)
-
-
-T = TypeVar("T")
-
-
-def topsort(data: dict[T, set[T]]) -> Iterable[set[T]]:
-    """Topological sort.
-
-    Args:
-      data: A map from vertices to all vertices that it has an edge
-            connecting it to.  NOTE: This data structure
-            is modified in place -- for normalization purposes,
-            self-dependencies are removed and entries representing
-            orphans are added.
-
-    Returns:
-      An iterator yielding sets of vertices that have an equivalent
-      ordering.
-
-    Example:
-      Suppose the input has the following structure:
-
-        {A: {B, C}, B: {D}, C: {D}}
-
-      This is normalized to:
-
-        {A: {B, C}, B: {D}, C: {D}, D: {}}
-
-      The algorithm will yield the following values:
-
-        {D}
-        {B, C}
-        {A}
-
-    From https://code.activestate.com/recipes/577413/.
-    """
-    # TODO: Use a faster algorithm?
-    for k, v in data.items():
-        v.discard(k)  # Ignore self dependencies.
-    for item in set.union(*data.values()) - set(data.keys()):
-        data[item] = set()
-    while True:
-        ready = {item for item, dep in data.items() if not dep}
-        if not ready:
-            break
-        yield ready
-        data = {item: (dep - ready) for item, dep in data.items() if item not in ready}
-    assert not data, f"A cyclic dependency exists amongst {data!r}"
-
-
 def missing_stubs_file(cache_dir: str) -> str:
     return os.path.join(cache_dir, "missing_stubs")
 
diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py
index 4b204a80c1308..43896171eadc8 100644
--- a/mypy/checkexpr.py
+++ b/mypy/checkexpr.py
@@ -12,7 +12,7 @@
 import mypy.errorcodes as codes
 from mypy import applytype, erasetype, join, message_registry, nodes, operators, types
 from mypy.argmap import ArgTypeExpander, map_actuals_to_formals, map_formals_to_actuals
-from mypy.checkmember import analyze_member_access, type_object_type
+from mypy.checkmember import analyze_member_access, freeze_all_type_vars, type_object_type
 from mypy.checkstrformat import StringFormatterChecker
 from mypy.erasetype import erase_type, remove_instance_last_known_values, replace_meta_vars
 from mypy.errors import ErrorWatcher, report_internal_error
@@ -98,8 +98,15 @@
 )
 from mypy.semanal_enum import ENUM_BASES
 from mypy.state import state
-from mypy.subtypes import is_equivalent, is_same_type, is_subtype, non_method_protocol_members
+from mypy.subtypes import (
+    find_member,
+    is_equivalent,
+    is_same_type,
+    is_subtype,
+    non_method_protocol_members,
+)
 from mypy.traverser import has_await_expression
+from mypy.type_visitor import TypeTranslator
 from mypy.typeanal import (
     check_for_explicit_any,
     has_any_from_unimported_type,
@@ -114,6 +121,7 @@
     false_only,
     fixup_partial_type,
     function_type,
+    get_type_vars,
     is_literal_type_like,
     make_simplified_union,
     simple_literal_type,
@@ -146,6 +154,7 @@
     TypedDictType,
     TypeOfAny,
     TypeType,
+    TypeVarLikeType,
     TypeVarTupleType,
     TypeVarType,
     UninhabitedType,
@@ -300,6 +309,7 @@ def __init__(
         # on whether current expression is a callee, to give better error messages
         # related to type context.
         self.is_callee = False
+        type_state.infer_polymorphic = self.chk.options.new_type_inference
 
     def reset(self) -> None:
         self.resolved_type = {}
@@ -1791,6 +1801,51 @@ def infer_function_type_arguments(
                     inferred_args[0] = self.named_type("builtins.str")
                 elif not first_arg or not is_subtype(self.named_type("builtins.str"), first_arg):
                     self.chk.fail(message_registry.KEYWORD_ARGUMENT_REQUIRES_STR_KEY_TYPE, context)
+
+            if self.chk.options.new_type_inference and any(
+                a is None
+                or isinstance(get_proper_type(a), UninhabitedType)
+                or set(get_type_vars(a)) & set(callee_type.variables)
+                for a in inferred_args
+            ):
+                # If the regular two-phase inference didn't work, try inferring type
+                # variables while allowing for polymorphic solutions, i.e. for solutions
+                # potentially involving free variables.
+                # TODO: support the similar inference for return type context.
+                poly_inferred_args = infer_function_type_arguments(
+                    callee_type,
+                    arg_types,
+                    arg_kinds,
+                    formal_to_actual,
+                    context=self.argument_infer_context(),
+                    strict=self.chk.in_checked_function(),
+                    allow_polymorphic=True,
+                )
+                for i, pa in enumerate(get_proper_types(poly_inferred_args)):
+                    if isinstance(pa, (NoneType, UninhabitedType)) or has_erased_component(pa):
+                        # Indicate that free variables should not be applied in the call below.
+                        poly_inferred_args[i] = None
+                poly_callee_type = self.apply_generic_arguments(
+                    callee_type, poly_inferred_args, context
+                )
+                yes_vars = poly_callee_type.variables
+                no_vars = {v for v in callee_type.variables if v not in poly_callee_type.variables}
+                if not set(get_type_vars(poly_callee_type)) & no_vars:
+                    # Try applying inferred polymorphic type if possible, e.g. Callable[[T], T] can
+                    # be interpreted as def [T] (T) -> T, but dict[T, T] cannot be expressed.
+                    applied = apply_poly(poly_callee_type, yes_vars)
+                    if applied is not None and poly_inferred_args != [UninhabitedType()] * len(
+                        poly_inferred_args
+                    ):
+                        freeze_all_type_vars(applied)
+                        return applied
+                # If it didn't work, erase free variables as <nothing>, to avoid confusing errors.
+                inferred_args = [
+                    expand_type(a, {v.id: UninhabitedType() for v in callee_type.variables})
+                    if a is not None
+                    else None
+                    for a in inferred_args
+                ]
         else:
             # In dynamically typed functions use implicit 'Any' types for
             # type variables.
@@ -5393,6 +5448,92 @@ def replace_callable_return_type(c: CallableType, new_ret_type: Type) -> Callabl
     return c.copy_modified(ret_type=new_ret_type)
 
 
+def apply_poly(tp: CallableType, poly_tvars: Sequence[TypeVarLikeType]) -> Optional[CallableType]:
+    """Make free type variables generic in the type if possible.
+
+    This will translate the type `tp` while trying to create valid bindings for
+    type variables `poly_tvars` while traversing the type. This follows the same rules
+    as we do during semantic analysis phase, examples:
+      * Callable[Callable[[T], T], T] -> def [T] (def (T) -> T) -> T
+      * Callable[[], Callable[[T], T]] -> def () -> def [T] (T -> T)
+      * List[T] -> None (not possible)
+    """
+    try:
+        return tp.copy_modified(
+            arg_types=[t.accept(PolyTranslator(poly_tvars)) for t in tp.arg_types],
+            ret_type=tp.ret_type.accept(PolyTranslator(poly_tvars)),
+            variables=[],
+        )
+    except PolyTranslationError:
+        return None
+
+
+class PolyTranslationError(Exception):
+    pass
+
+
+class PolyTranslator(TypeTranslator):
+    """Make free type variables generic in the type if possible.
+
+    See docstring for apply_poly() for details.
+    """
+
+    def __init__(self, poly_tvars: Sequence[TypeVarLikeType]) -> None:
+        self.poly_tvars = set(poly_tvars)
+        # This is a simplified version of TypeVarScope used during semantic analysis.
+        self.bound_tvars: set[TypeVarLikeType] = set()
+        self.seen_aliases: set[TypeInfo] = set()
+
+    def visit_callable_type(self, t: CallableType) -> Type:
+        found_vars = set()
+        for arg in t.arg_types:
+            found_vars |= set(get_type_vars(arg)) & self.poly_tvars
+
+        found_vars -= self.bound_tvars
+        self.bound_tvars |= found_vars
+        result = super().visit_callable_type(t)
+        self.bound_tvars -= found_vars
+
+        assert isinstance(result, ProperType) and isinstance(result, CallableType)
+        result.variables = list(result.variables) + list(found_vars)
+        return result
+
+    def visit_type_var(self, t: TypeVarType) -> Type:
+        if t in self.poly_tvars and t not in self.bound_tvars:
+            raise PolyTranslationError()
+        return super().visit_type_var(t)
+
+    def visit_param_spec(self, t: ParamSpecType) -> Type:
+        # TODO: Support polymorphic apply for ParamSpec.
+        raise PolyTranslationError()
+
+    def visit_type_var_tuple(self, t: TypeVarTupleType) -> Type:
+        # TODO: Support polymorphic apply for TypeVarTuple.
+        raise PolyTranslationError()
+
+    def visit_type_alias_type(self, t: TypeAliasType) -> Type:
+        if not t.args:
+            return t.copy_modified()
+        if not t.is_recursive:
+            return get_proper_type(t).accept(self)
+        # We can't handle polymorphic application for recursive generic aliases
+        # without risking an infinite recursion, just give up for now.
+        raise PolyTranslationError()
+
+    def visit_instance(self, t: Instance) -> Type:
+        # There is the same problem with callback protocols as with aliases
+        # (callback protocols are essentially more flexible aliases to callables).
+        # Note: consider supporting bindings in instances, e.g. LRUCache[[x: T], T].
+        if t.args and t.type.is_protocol and t.type.protocol_members == ["__call__"]:
+            if t.type in self.seen_aliases:
+                raise PolyTranslationError()
+            self.seen_aliases.add(t.type)
+            call = find_member("__call__", t, t, is_operator=True)
+            assert call is not None
+            return call.accept(self)
+        return super().visit_instance(t)
+
+
 class ArgInferSecondPassQuery(types.BoolTypeQuery):
     """Query whether an argument type should be inferred in the second pass.
 
diff --git a/mypy/constraints.py b/mypy/constraints.py
index 33230871b505d..803b9819be6f9 100644
--- a/mypy/constraints.py
+++ b/mypy/constraints.py
@@ -886,7 +886,30 @@ def visit_callable_type(self, template: CallableType) -> list[Constraint]:
             param_spec = template.param_spec()
             if param_spec is None:
                 # FIX verify argument counts
-                # FIX what if one of the functions is generic
+                # TODO: Erase template variables if it is generic?
+                if (
+                    type_state.infer_polymorphic
+                    and cactual.variables
+                    and cactual.param_spec() is None
+                    # Technically, the correct inferred type for application of e.g.
+                    # Callable[..., T] -> Callable[..., T] (with literal ellipsis), to a generic
+                    # like U -> U, should be Callable[..., Any], but if U is a self-type, we can
+                    # allow it to leak, to be later bound to self. A bunch of existing code
+                    # depends on this old behaviour.
+                    and not any(tv.id.raw_id == 0 for tv in cactual.variables)
+                ):
+                    # If actual is generic, unify it with template. Note: this is
+                    # not an ideal solution (which would be adding the generic variables
+                    # to the constraint inference set), but it's a good first approximation,
+                    # and this will prevent leaking these variables in the solutions.
+                    # Note: this may infer constraints like T <: S or T <: List[S]
+                    # that contain variables in the target.
+                    unified = mypy.subtypes.unify_generic_callable(
+                        cactual, template, ignore_return=True
+                    )
+                    if unified is not None:
+                        cactual = unified
+                        res.extend(infer_constraints(cactual, template, neg_op(self.direction)))
 
                 # We can't infer constraints from arguments if the template is Callable[..., T]
                 # (with literal '...').
diff --git a/mypy/graph_utils.py b/mypy/graph_utils.py
new file mode 100644
index 0000000000000..399301a6b0fdd
--- /dev/null
+++ b/mypy/graph_utils.py
@@ -0,0 +1,112 @@
+"""Helpers for manipulations with graphs."""
+
+from __future__ import annotations
+
+from typing import AbstractSet, Iterable, Iterator, TypeVar
+
+T = TypeVar("T")
+
+
+def strongly_connected_components(
+    vertices: AbstractSet[T], edges: dict[T, list[T]]
+) -> Iterator[set[T]]:
+    """Compute Strongly Connected Components of a directed graph.
+
+    Args:
+      vertices: the labels for the vertices
+      edges: for each vertex, gives the target vertices of its outgoing edges
+
+    Returns:
+      An iterator yielding strongly connected components, each
+      represented as a set of vertices.  Each input vertex will occur
+      exactly once; vertices not part of a SCC are returned as
+      singleton sets.
+
+    From https://code.activestate.com/recipes/578507/.
+    """
+    identified: set[T] = set()
+    stack: list[T] = []
+    index: dict[T, int] = {}
+    boundaries: list[int] = []
+
+    def dfs(v: T) -> Iterator[set[T]]:
+        index[v] = len(stack)
+        stack.append(v)
+        boundaries.append(index[v])
+
+        for w in edges[v]:
+            if w not in index:
+                yield from dfs(w)
+            elif w not in identified:
+                while index[w] < boundaries[-1]:
+                    boundaries.pop()
+
+        if boundaries[-1] == index[v]:
+            boundaries.pop()
+            scc = set(stack[index[v] :])
+            del stack[index[v] :]
+            identified.update(scc)
+            yield scc
+
+    for v in vertices:
+        if v not in index:
+            yield from dfs(v)
+
+
+def prepare_sccs(
+    sccs: list[set[T]], edges: dict[T, list[T]]
+) -> dict[AbstractSet[T], set[AbstractSet[T]]]:
+    """Use original edges to organize SCCs in a graph by dependencies between them."""
+    sccsmap = {v: frozenset(scc) for scc in sccs for v in scc}
+    data: dict[AbstractSet[T], set[AbstractSet[T]]] = {}
+    for scc in sccs:
+        deps: set[AbstractSet[T]] = set()
+        for v in scc:
+            deps.update(sccsmap[x] for x in edges[v])
+        data[frozenset(scc)] = deps
+    return data
+
+
+def topsort(data: dict[T, set[T]]) -> Iterable[set[T]]:
+    """Topological sort.
+
+    Args:
+      data: A map from vertices to all vertices that it has an edge
+            connecting it to.  NOTE: This data structure
+            is modified in place -- for normalization purposes,
+            self-dependencies are removed and entries representing
+            orphans are added.
+
+    Returns:
+      An iterator yielding sets of vertices that have an equivalent
+      ordering.
+
+    Example:
+      Suppose the input has the following structure:
+
+        {A: {B, C}, B: {D}, C: {D}}
+
+      This is normalized to:
+
+        {A: {B, C}, B: {D}, C: {D}, D: {}}
+
+      The algorithm will yield the following values:
+
+        {D}
+        {B, C}
+        {A}
+
+    From https://code.activestate.com/recipes/577413/.
+    """
+    # TODO: Use a faster algorithm?
+    for k, v in data.items():
+        v.discard(k)  # Ignore self dependencies.
+    for item in set.union(*data.values()) - set(data.keys()):
+        data[item] = set()
+    while True:
+        ready = {item for item, dep in data.items() if not dep}
+        if not ready:
+            break
+        yield ready
+        data = {item: (dep - ready) for item, dep in data.items() if item not in ready}
+    assert not data, f"A cyclic dependency exists amongst {data!r}"
diff --git a/mypy/infer.py b/mypy/infer.py
index fbec3d7c4278b..66ca4169e2ff5 100644
--- a/mypy/infer.py
+++ b/mypy/infer.py
@@ -36,6 +36,7 @@ def infer_function_type_arguments(
     formal_to_actual: list[list[int]],
     context: ArgumentInferContext,
     strict: bool = True,
+    allow_polymorphic: bool = False,
 ) -> list[Type | None]:
     """Infer the type arguments of a generic function.
 
@@ -57,7 +58,7 @@ def infer_function_type_arguments(
 
     # Solve constraints.
     type_vars = callee_type.type_var_ids()
-    return solve_constraints(type_vars, constraints, strict)
+    return solve_constraints(type_vars, constraints, strict, allow_polymorphic)
 
 
 def infer_type_arguments(
diff --git a/mypy/main.py b/mypy/main.py
index 81a0a045745bd..b60c5b2a6bba3 100644
--- a/mypy/main.py
+++ b/mypy/main.py
@@ -983,6 +983,11 @@ def add_invertible_flag(
         dest="custom_typing_module",
         help="Use a custom typing module",
     )
+    internals_group.add_argument(
+        "--new-type-inference",
+        action="store_true",
+        help="Enable new experimental type inference algorithm",
+    )
     internals_group.add_argument(
         "--disable-recursive-aliases",
         action="store_true",
diff --git a/mypy/options.py b/mypy/options.py
index 2785d2034c540..f75734124eb0f 100644
--- a/mypy/options.py
+++ b/mypy/options.py
@@ -344,6 +344,8 @@ def __init__(self) -> None:
         # skip most errors after this many messages have been reported.
         # -1 means unlimited.
         self.many_errors_threshold = defaults.MANY_ERRORS_THRESHOLD
+        # Enable new experimental type inference algorithm.
+        self.new_type_inference = False
         # Disable recursive type aliases (currently experimental)
         self.disable_recursive_aliases = False
         # Deprecated reverse version of the above, do not use.
diff --git a/mypy/semanal.py b/mypy/semanal.py
index 073bde6616174..249a57d550b2f 100644
--- a/mypy/semanal.py
+++ b/mypy/semanal.py
@@ -234,7 +234,6 @@
     fix_instance_types,
     has_any_from_unimported_type,
     no_subscript_builtin_alias,
-    remove_dups,
     type_constructors,
 )
 from mypy.typeops import function_type, get_type_vars, try_getting_str_literals_from_type
@@ -277,6 +276,7 @@
     get_proper_type,
     get_proper_types,
     is_named_instance,
+    remove_dups,
 )
 from mypy.types_utils import is_invalid_recursive_alias, store_argument_type
 from mypy.typevars import fill_typevars
diff --git a/mypy/solve.py b/mypy/solve.py
index b8304d29c1ce9..6693d66f3479d 100644
--- a/mypy/solve.py
+++ b/mypy/solve.py
@@ -2,27 +2,35 @@
 
 from __future__ import annotations
 
-from collections import defaultdict
+from typing import Iterable
 
-from mypy.constraints import SUPERTYPE_OF, Constraint
+from mypy.constraints import SUBTYPE_OF, SUPERTYPE_OF, Constraint, neg_op
+from mypy.expandtype import expand_type
+from mypy.graph_utils import prepare_sccs, strongly_connected_components, topsort
 from mypy.join import join_types
 from mypy.meet import meet_types
 from mypy.subtypes import is_subtype
+from mypy.typeops import get_type_vars
 from mypy.types import (
     AnyType,
     ProperType,
     Type,
     TypeOfAny,
     TypeVarId,
+    TypeVarType,
     UninhabitedType,
     UnionType,
     get_proper_type,
+    remove_dups,
 )
 from mypy.typestate import type_state
 
 
 def solve_constraints(
-    vars: list[TypeVarId], constraints: list[Constraint], strict: bool = True
+    vars: list[TypeVarId],
+    constraints: list[Constraint],
+    strict: bool = True,
+    allow_polymorphic: bool = False,
 ) -> list[Type | None]:
     """Solve type constraints.
 
@@ -33,62 +41,355 @@ def solve_constraints(
     pick NoneType as the value of the type variable.  If strict=False,
     pick AnyType.
     """
+    if not vars:
+        return []
+    if allow_polymorphic:
+        # Constraints like T :> S and S <: T are semantically the same, but they are
+        # represented differently. Normalize the constraint list w.r.t this equivalence.
+        constraints = normalize_constraints(constraints, vars)
+
     # Collect a list of constraints for each type variable.
-    cmap: dict[TypeVarId, list[Constraint]] = defaultdict(list)
+    cmap: dict[TypeVarId, list[Constraint]] = {tv: [] for tv in vars}
     for con in constraints:
-        cmap[con.type_var].append(con)
+        if con.type_var in vars:
+            cmap[con.type_var].append(con)
+
+    if allow_polymorphic:
+        solutions = solve_non_linear(vars, constraints, cmap)
+    else:
+        solutions = {}
+        for tv, cs in cmap.items():
+            if not cs:
+                continue
+            lowers = [c.target for c in cs if c.op == SUPERTYPE_OF]
+            uppers = [c.target for c in cs if c.op == SUBTYPE_OF]
+            solutions[tv] = solve_one(lowers, uppers, [])
 
     res: list[Type | None] = []
+    for v in vars:
+        if v in solutions:
+            res.append(solutions[v])
+        else:
+            # No constraints for type variable -- 'UninhabitedType' is the most specific type.
+            candidate: Type
+            if strict:
+                candidate = UninhabitedType()
+                candidate.ambiguous = True
+            else:
+                candidate = AnyType(TypeOfAny.special_form)
+            res.append(candidate)
+    return res
+
+
+def solve_non_linear(
+    vars: list[TypeVarId], constraints: list[Constraint], cmap: dict[TypeVarId, list[Constraint]]
+) -> dict[TypeVarId, Type | None]:
+    """Solve set of constraints that may include non-linear ones, like T <: List[S].
 
-    # Solve each type variable separately.
+    The whole algorithm consists of five steps:
+      * Propagate via linear constraints to get all possible constraints for each variable
+      * Find dependencies between type variables, group them in SCCs, and sort topologically
+      * Check all SCC are intrinsically linear, we can't solve (express) T <: List[T]
+      * Variables in leaf SCCs that don't have constant bounds are free (choose one per SCC)
+      * Solve constraints iteratively starting from leafs, updating targets after each step.
+    """
+    extra_constraints = []
     for tvar in vars:
-        bottom: Type | None = None
-        top: Type | None = None
-        candidate: Type | None = None
-
-        # Process each constraint separately, and calculate the lower and upper
-        # bounds based on constraints. Note that we assume that the constraint
-        # targets do not have constraint references.
-        for c in cmap.get(tvar, []):
-            if c.op == SUPERTYPE_OF:
-                if bottom is None:
-                    bottom = c.target
-                else:
-                    if type_state.infer_unions:
-                        # This deviates from the general mypy semantics because
-                        # recursive types are union-heavy in 95% of cases.
-                        bottom = UnionType.make_union([bottom, c.target])
-                    else:
-                        bottom = join_types(bottom, c.target)
+        extra_constraints.extend(propagate_constraints_for(tvar, SUBTYPE_OF, cmap))
+        extra_constraints.extend(propagate_constraints_for(tvar, SUPERTYPE_OF, cmap))
+    constraints += remove_dups(extra_constraints)
+
+    # Recompute constraint map after propagating.
+    cmap = {tv: [] for tv in vars}
+    for con in constraints:
+        if con.type_var in vars:
+            cmap[con.type_var].append(con)
+
+    dmap = compute_dependencies(cmap)
+    sccs = list(strongly_connected_components(set(vars), dmap))
+    if all(check_linear(scc, cmap) for scc in sccs):
+        raw_batches = list(topsort(prepare_sccs(sccs, dmap)))
+        leafs = raw_batches[0]
+        free_vars = []
+        for scc in leafs:
+            # If all constrain targets in this SCC are type variables within the
+            # same SCC then the only meaningful solution we can express, is that
+            # each variable is equal to a new free variable. For example if we
+            # have T <: S, S <: U, we deduce: T = S = U = <free>.
+            if all(
+                isinstance(c.target, TypeVarType) and c.target.id in vars
+                for tv in scc
+                for c in cmap[tv]
+            ):
+                # For convenience with current type application machinery, we randomly
+                # choose one of the existing type variables in SCC and designate it as free
+                # instead of defining a new type variable as a common solution.
+                # TODO: be careful about upper bounds (or values) when introducing free vars.
+                free_vars.append(sorted(scc, key=lambda x: x.raw_id)[0])
+
+        # Flatten the SCCs that are independent, we can solve them together,
+        # since we don't need to update any targets in between.
+        batches = []
+        for batch in raw_batches:
+            next_bc = []
+            for scc in batch:
+                next_bc.extend(list(scc))
+            batches.append(next_bc)
+
+        solutions: dict[TypeVarId, Type | None] = {}
+        for flat_batch in batches:
+            solutions.update(solve_iteratively(flat_batch, cmap, free_vars))
+        # We remove the solutions like T = T for free variables. This will indicate
+        # to the apply function, that they should not be touched.
+        # TODO: return list of free type variables explicitly, this logic is fragile
+        # (but if we do, we need to be careful everything works in incremental modes).
+        for tv in free_vars:
+            if tv in solutions:
+                del solutions[tv]
+        return solutions
+    return {}
+
+
+def solve_iteratively(
+    batch: list[TypeVarId], cmap: dict[TypeVarId, list[Constraint]], free_vars: list[TypeVarId]
+) -> dict[TypeVarId, Type | None]:
+    """Solve constraints sequentially, updating constraint targets after each step.
+
+    We solve for type variables that appear in `batch`. If a constraint target is not constant
+    (i.e. constraint looks like T :> F[S, ...]), we substitute solutions found so far in
+    the target F[S, ...].  This way we can gradually solve for all variables in the batch taking
+    one solvable variable at a time (i.e. such a variable that has at least one constant bound).
+
+    Importantly, variables in free_vars are considered constants, so for example if we have just
+    one initial constraint T <: List[S], we will have two SCCs {T} and {S}, then we first
+    designate S as free, and therefore T = List[S] is a valid solution for T.
+    """
+    solutions = {}
+    relevant_constraints = []
+    for tv in batch:
+        relevant_constraints.extend(cmap.get(tv, []))
+    lowers, uppers = transitive_closure(batch, relevant_constraints)
+    s_batch = set(batch)
+    not_allowed_vars = [v for v in batch if v not in free_vars]
+    while s_batch:
+        for tv in s_batch:
+            if any(not get_vars(l, not_allowed_vars) for l in lowers[tv]) or any(
+                not get_vars(u, not_allowed_vars) for u in uppers[tv]
+            ):
+                solvable_tv = tv
+                break
+        else:
+            break
+        # Solve each solvable type variable separately.
+        s_batch.remove(solvable_tv)
+        result = solve_one(lowers[solvable_tv], uppers[solvable_tv], not_allowed_vars)
+        solutions[solvable_tv] = result
+        if result is None:
+            # TODO: support backtracking lower/upper bound choices
+            # (will require switching this function from iterative to recursive).
+            continue
+        # Update the (transitive) constraints if there is a solution.
+        subs = {solvable_tv: result}
+        lowers = {tv: {expand_type(l, subs) for l in lowers[tv]} for tv in lowers}
+        uppers = {tv: {expand_type(u, subs) for u in uppers[tv]} for tv in uppers}
+        for v in cmap:
+            for c in cmap[v]:
+                c.target = expand_type(c.target, subs)
+    return solutions
+
+
+def solve_one(
+    lowers: Iterable[Type], uppers: Iterable[Type], not_allowed_vars: list[TypeVarId]
+) -> Type | None:
+    """Solve constraints by finding by using meets of upper bounds, and joins of lower bounds."""
+    bottom: Type | None = None
+    top: Type | None = None
+    candidate: Type | None = None
+
+    # Process each bound separately, and calculate the lower and upper
+    # bounds based on constraints. Note that we assume that the constraint
+    # targets do not have constraint references.
+    for target in lowers:
+        # There may be multiple steps needed to solve all vars within a
+        # (linear) SCC. We ignore targets pointing to not yet solved vars.
+        if get_vars(target, not_allowed_vars):
+            continue
+        if bottom is None:
+            bottom = target
+        else:
+            if type_state.infer_unions:
+                # This deviates from the general mypy semantics because
+                # recursive types are union-heavy in 95% of cases.
+                bottom = UnionType.make_union([bottom, target])
             else:
-                if top is None:
-                    top = c.target
-                else:
-                    top = meet_types(top, c.target)
-
-        p_top = get_proper_type(top)
-        p_bottom = get_proper_type(bottom)
-        if isinstance(p_top, AnyType) or isinstance(p_bottom, AnyType):
-            source_any = top if isinstance(p_top, AnyType) else bottom
-            assert isinstance(source_any, ProperType) and isinstance(source_any, AnyType)
-            res.append(AnyType(TypeOfAny.from_another_any, source_any=source_any))
+                bottom = join_types(bottom, target)
+
+    for target in uppers:
+        # Same as above.
+        if get_vars(target, not_allowed_vars):
             continue
-        elif bottom is None:
-            if top:
-                candidate = top
+        if top is None:
+            top = target
+        else:
+            top = meet_types(top, target)
+
+    p_top = get_proper_type(top)
+    p_bottom = get_proper_type(bottom)
+    if isinstance(p_top, AnyType) or isinstance(p_bottom, AnyType):
+        source_any = top if isinstance(p_top, AnyType) else bottom
+        assert isinstance(source_any, ProperType) and isinstance(source_any, AnyType)
+        return AnyType(TypeOfAny.from_another_any, source_any=source_any)
+    elif bottom is None:
+        if top:
+            candidate = top
+        else:
+            # No constraints for type variable
+            return None
+    elif top is None:
+        candidate = bottom
+    elif is_subtype(bottom, top):
+        candidate = bottom
+    else:
+        candidate = None
+    return candidate
+
+
+def normalize_constraints(
+    constraints: list[Constraint], vars: list[TypeVarId]
+) -> list[Constraint]:
+    """Normalize list of constraints (to simplify life for the non-linear solver).
+
+    This includes two things currently:
+      * Complement T :> S by S <: T
+      * Remove strict duplicates
+    """
+    res = constraints.copy()
+    for c in constraints:
+        if isinstance(c.target, TypeVarType):
+            res.append(Constraint(c.target, neg_op(c.op), c.origin_type_var))
+    return [c for c in remove_dups(constraints) if c.type_var in vars]
+
+
+def propagate_constraints_for(
+    var: TypeVarId, direction: int, cmap: dict[TypeVarId, list[Constraint]]
+) -> list[Constraint]:
+    """Propagate via linear constraints to get additional constraints for `var`.
+
+    For example if we have constraints:
+        [T <: int, S <: T, S :> str]
+    we can add two more
+        [S <: int, T :> str]
+    """
+    extra_constraints = []
+    seen = set()
+    front = [var]
+    if cmap[var]:
+        var_def = cmap[var][0].origin_type_var
+    else:
+        return []
+    while front:
+        tv = front.pop(0)
+        for c in cmap[tv]:
+            if (
+                isinstance(c.target, TypeVarType)
+                and c.target.id not in seen
+                and c.target.id in cmap
+                and c.op == direction
+            ):
+                front.append(c.target.id)
+                seen.add(c.target.id)
+            elif c.op == direction:
+                new_c = Constraint(var_def, direction, c.target)
+                if new_c not in cmap[var]:
+                    extra_constraints.append(new_c)
+    return extra_constraints
+
+
+def transitive_closure(
+    tvars: list[TypeVarId], constraints: list[Constraint]
+) -> tuple[dict[TypeVarId, set[Type]], dict[TypeVarId, set[Type]]]:
+    """Find transitive closure for given constraints on type variables.
+
+    Transitive closure gives maximal set of lower/upper bounds for each type variable,
+    such that we cannot deduce any further bounds by chaining other existing bounds.
+
+    For example if we have initial constraints [T <: S, S <: U, U <: int], the transitive
+    closure is given by:
+      * {} <: T <: {S, U, int}
+      * {T} <: S <: {U, int}
+      * {T, S} <: U <: {int}
+    """
+    # TODO: merge propagate_constraints_for() into this function.
+    # TODO: add secondary constraints here to make the algorithm complete.
+    uppers: dict[TypeVarId, set[Type]] = {tv: set() for tv in tvars}
+    lowers: dict[TypeVarId, set[Type]] = {tv: set() for tv in tvars}
+    graph: set[tuple[TypeVarId, TypeVarId]] = set()
+
+    # Prime the closure with the initial trivial values.
+    for c in constraints:
+        if isinstance(c.target, TypeVarType) and c.target.id in tvars:
+            if c.op == SUBTYPE_OF:
+                graph.add((c.type_var, c.target.id))
             else:
-                # No constraints for type variable -- 'UninhabitedType' is the most specific type.
-                if strict:
-                    candidate = UninhabitedType()
-                    candidate.ambiguous = True
-                else:
-                    candidate = AnyType(TypeOfAny.special_form)
-        elif top is None:
-            candidate = bottom
-        elif is_subtype(bottom, top):
-            candidate = bottom
+                graph.add((c.target.id, c.type_var))
+        if c.op == SUBTYPE_OF:
+            uppers[c.type_var].add(c.target)
         else:
-            candidate = None
-        res.append(candidate)
+            lowers[c.type_var].add(c.target)
+
+    # At this stage we know that constant bounds have been propagated already, so we
+    # only need to propagate linear constraints.
+    for c in constraints:
+        if isinstance(c.target, TypeVarType) and c.target.id in tvars:
+            if c.op == SUBTYPE_OF:
+                lower, upper = c.type_var, c.target.id
+            else:
+                lower, upper = c.target.id, c.type_var
+            extras = {
+                (l, u) for l in tvars for u in tvars if (l, lower) in graph and (upper, u) in graph
+            }
+            graph |= extras
+            for u in tvars:
+                if (upper, u) in graph:
+                    lowers[u] |= lowers[lower]
+            for l in tvars:
+                if (l, lower) in graph:
+                    uppers[l] |= uppers[upper]
+    return lowers, uppers
 
+
+def compute_dependencies(
+    cmap: dict[TypeVarId, list[Constraint]]
+) -> dict[TypeVarId, list[TypeVarId]]:
+    """Compute dependencies between type variables induced by constraints.
+
+    If we have a constraint like T <: List[S], we say that T depends on S, since
+    we will need to solve for S first before we can solve for T.
+    """
+    res = {}
+    vars = list(cmap.keys())
+    for tv in cmap:
+        deps = set()
+        for c in cmap[tv]:
+            deps |= get_vars(c.target, vars)
+        res[tv] = list(deps)
     return res
+
+
+def check_linear(scc: set[TypeVarId], cmap: dict[TypeVarId, list[Constraint]]) -> bool:
+    """Check there are only linear constraints between type variables in SCC.
+
+    Linear are constraints like T <: S (while T <: F[S] are non-linear).
+    """
+    for tv in scc:
+        if any(
+            get_vars(c.target, list(scc)) and not isinstance(c.target, TypeVarType)
+            for c in cmap[tv]
+        ):
+            return False
+    return True
+
+
+def get_vars(target: Type, vars: list[TypeVarId]) -> set[TypeVarId]:
+    """Find type variables for which we are solving in a target type."""
+    return {tv.id for tv in get_type_vars(target)} & set(vars)
diff --git a/mypy/test/testgraph.py b/mypy/test/testgraph.py
index ce7697142ff2c..b0d148d5ae9c6 100644
--- a/mypy/test/testgraph.py
+++ b/mypy/test/testgraph.py
@@ -5,17 +5,10 @@
 import sys
 from typing import AbstractSet
 
-from mypy.build import (
-    BuildManager,
-    BuildSourceSet,
-    State,
-    order_ascc,
-    sorted_components,
-    strongly_connected_components,
-    topsort,
-)
+from mypy.build import BuildManager, BuildSourceSet, State, order_ascc, sorted_components
 from mypy.errors import Errors
 from mypy.fscache import FileSystemCache
+from mypy.graph_utils import strongly_connected_components, topsort
 from mypy.modulefinder import SearchPaths
 from mypy.options import Options
 from mypy.plugin import Plugin
diff --git a/mypy/typeanal.py b/mypy/typeanal.py
index d1e6e315b9e3f..39a44a2893659 100644
--- a/mypy/typeanal.py
+++ b/mypy/typeanal.py
@@ -1843,19 +1843,6 @@ def set_any_tvars(
     return TypeAliasType(node, args, newline, newcolumn)
 
 
-def remove_dups(tvars: list[T]) -> list[T]:
-    if len(tvars) <= 1:
-        return tvars
-    # Get unique elements in order of appearance
-    all_tvars: set[T] = set()
-    new_tvars: list[T] = []
-    for t in tvars:
-        if t not in all_tvars:
-            new_tvars.append(t)
-            all_tvars.add(t)
-    return new_tvars
-
-
 def flatten_tvars(lists: list[list[T]]) -> list[T]:
     result: list[T] = []
     for lst in lists:
diff --git a/mypy/types.py b/mypy/types.py
index 5fbdd385826c3..e4c22da12603e 100644
--- a/mypy/types.py
+++ b/mypy/types.py
@@ -3475,6 +3475,19 @@ def callable_with_ellipsis(any_type: AnyType, ret_type: Type, fallback: Instance
     )
 
 
+def remove_dups(types: list[T]) -> list[T]:
+    if len(types) <= 1:
+        return types
+    # Get unique elements in order of appearance
+    all_types: set[T] = set()
+    new_types: list[T] = []
+    for t in types:
+        if t not in all_types:
+            new_types.append(t)
+            all_types.add(t)
+    return new_types
+
+
 # This cyclic import is unfortunate, but to avoid it we would need to move away all uses
 # of get_proper_type() from types.py. Majority of them have been removed, but few remaining
 # are quite tricky to get rid of, but ultimately we want to do it at some point.
diff --git a/mypy/typestate.py b/mypy/typestate.py
index 9f65481e5e946..ff5933af5928d 100644
--- a/mypy/typestate.py
+++ b/mypy/typestate.py
@@ -93,6 +93,9 @@ class TypeState:
     inferring: Final[list[tuple[Type, Type]]]
     # Whether to use joins or unions when solving constraints, see checkexpr.py for details.
     infer_unions: bool
+    # Whether to use new type inference algorithm that can infer polymorphic types.
+    # This is temporary and will be removed soon when new algorithm is more polished.
+    infer_polymorphic: bool
 
     # N.B: We do all of the accesses to these properties through
     # TypeState, instead of making these classmethods and accessing
@@ -110,6 +113,7 @@ def __init__(self) -> None:
         self._assuming_proper = []
         self.inferring = []
         self.infer_unions = False
+        self.infer_polymorphic = False
 
     def is_assumed_subtype(self, left: Type, right: Type) -> bool:
         for l, r in reversed(self._assuming):
@@ -311,7 +315,7 @@ def add_all_protocol_deps(self, deps: dict[str, set[str]]) -> None:
 def reset_global_state() -> None:
     """Reset most existing global state.
 
-    Currently most of it is in this module. Few exceptions are strict optional status and
+    Currently most of it is in this module. Few exceptions are strict optional status
     and functools.lru_cache.
     """
     type_state.reset_all_subtype_caches()
diff --git a/test-data/unit/check-generics.test b/test-data/unit/check-generics.test
index 06b80be85096b..b78fd21d48175 100644
--- a/test-data/unit/check-generics.test
+++ b/test-data/unit/check-generics.test
@@ -2733,3 +2733,250 @@ dict1: Any
 dict2 = {"a": C1(), **{x: C2() for x in dict1}}
 reveal_type(dict2)  # N: Revealed type is "builtins.dict[Any, __main__.B]"
 [builtins fixtures/dict.pyi]
+
+-- Type inference for generic decorators applied to generic callables
+-- ------------------------------------------------------------------
+
+[case testInferenceAgainstGenericCallable]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, List
+
+X = TypeVar('X')
+T = TypeVar('T')
+
+def foo(x: Callable[[int], X]) -> List[X]:
+    ...
+def bar(x: Callable[[X], int]) -> List[X]:
+    ...
+
+def id(x: T) -> T:
+    ...
+reveal_type(foo(id))  # N: Revealed type is "builtins.list[builtins.int]"
+reveal_type(bar(id))  # N: Revealed type is "builtins.list[builtins.int]"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericCallableNoLeak]
+# flags: --new-type-inference
+from typing import TypeVar, Callable
+
+T = TypeVar('T')
+
+def f(x: Callable[..., T]) -> T:
+    return x()
+
+def tpl(x: T) -> T:
+    return x
+
+# This is valid because of "..."
+reveal_type(f(tpl))  # N: Revealed type is "Any"
+[out]
+
+[case testInferenceAgainstGenericCallableChain]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, List
+
+X = TypeVar('X')
+T = TypeVar('T')
+
+def chain(f: Callable[[X], T], g: Callable[[T], int]) -> Callable[[X], int]: ...
+def id(x: T) -> T:
+    ...
+reveal_type(chain(id, id))  # N: Revealed type is "def (builtins.int) -> builtins.int"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericCallableGeneric]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, List
+
+S = TypeVar('S')
+T = TypeVar('T')
+U = TypeVar('U')
+
+def dec(f: Callable[[S], T]) -> Callable[[S], List[T]]:
+    ...
+def id(x: U) -> U:
+    ...
+reveal_type(dec(id))  # N: Revealed type is "def [S] (S`1) -> builtins.list[S`1]"
+
+@dec
+def same(x: U) -> U:
+    ...
+reveal_type(same)  # N: Revealed type is "def [S] (S`3) -> builtins.list[S`3]"
+reveal_type(same(42))  # N: Revealed type is "builtins.list[builtins.int]"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericCallableGenericReverse]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, List
+
+S = TypeVar('S')
+T = TypeVar('T')
+U = TypeVar('U')
+
+def dec(f: Callable[[S], List[T]]) -> Callable[[S], T]:
+    ...
+def id(x: U) -> U:
+    ...
+reveal_type(dec(id))  # N: Revealed type is "def [T] (builtins.list[T`2]) -> T`2"
+
+@dec
+def same(x: U) -> U:
+    ...
+reveal_type(same)  # N: Revealed type is "def [T] (builtins.list[T`4]) -> T`4"
+reveal_type(same([42]))  # N: Revealed type is "builtins.int"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericCallableGenericArg]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, List
+
+S = TypeVar('S')
+T = TypeVar('T')
+U = TypeVar('U')
+
+def dec(f: Callable[[S], T]) -> Callable[[S], T]:
+    ...
+def test(x: U) -> List[U]:
+    ...
+reveal_type(dec(test))  # N: Revealed type is "def [S] (S`1) -> builtins.list[S`1]"
+
+@dec
+def single(x: U) -> List[U]:
+    ...
+reveal_type(single)  # N: Revealed type is "def [S] (S`3) -> builtins.list[S`3]"
+reveal_type(single(42))  # N: Revealed type is "builtins.list[builtins.int]"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericCallableGenericChain]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, List
+
+S = TypeVar('S')
+T = TypeVar('T')
+U = TypeVar('U')
+
+def comb(f: Callable[[T], S], g: Callable[[S], U]) -> Callable[[T], U]: ...
+def id(x: U) -> U:
+    ...
+reveal_type(comb(id, id))  # N: Revealed type is "def [T] (T`1) -> T`1"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericCallableGenericNonLinear]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, List
+
+S = TypeVar('S')
+T = TypeVar('T')
+U = TypeVar('U')
+
+def mix(fs: List[Callable[[S], T]]) -> Callable[[S], List[T]]:
+    def inner(x: S) -> List[T]:
+        return [f(x) for f in fs]
+    return inner
+
+# Errors caused by arg *name* mismatch are truly cryptic, but this is a known issue :/
+def id(__x: U) -> U:
+    ...
+fs = [id, id, id]
+reveal_type(mix(fs))  # N: Revealed type is "def [S] (S`3) -> builtins.list[S`3]"
+reveal_type(mix([id, id, id]))  # N: Revealed type is "def [S] (S`5) -> builtins.list[S`5]"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericCurry]
+# flags: --new-type-inference
+from typing import Callable, List, TypeVar
+
+S = TypeVar("S")
+T = TypeVar("T")
+U = TypeVar("U")
+V = TypeVar("V")
+
+def dec1(f: Callable[[T], S]) -> Callable[[], Callable[[T], S]]: ...
+def dec2(f: Callable[[T, U], S]) -> Callable[[U], Callable[[T], S]]: ...
+
+def test1(x: V) -> V: ...
+def test2(x: V, y: V) -> V: ...
+
+reveal_type(dec1(test1))  # N: Revealed type is "def () -> def [T] (T`1) -> T`1"
+# TODO: support this situation
+reveal_type(dec2(test2))  # N: Revealed type is "def (builtins.object) -> def (builtins.object) -> builtins.object"
+[builtins fixtures/paramspec.pyi]
+
+[case testInferenceAgainstGenericCallableGenericAlias]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, List
+
+S = TypeVar('S')
+T = TypeVar('T')
+U = TypeVar('U')
+
+A = Callable[[S], T]
+B = Callable[[S], List[T]]
+
+def dec(f: A[S, T]) -> B[S, T]:
+    ...
+def id(x: U) -> U:
+    ...
+reveal_type(dec(id))  # N: Revealed type is "def [S] (S`1) -> builtins.list[S`1]"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericCallableGenericProtocol]
+# flags: --strict-optional --new-type-inference
+from typing import TypeVar, Protocol, Generic, Optional
+
+T = TypeVar('T')
+
+class F(Protocol[T]):
+    def __call__(self, __x: T) -> T: ...
+
+def lift(f: F[T]) -> F[Optional[T]]: ...
+def g(x: T) -> T:
+    return x
+
+reveal_type(lift(g))  # N: Revealed type is "def [T] (Union[T`1, None]) -> Union[T`1, None]"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericSplitOrder]
+# flags: --strict-optional --new-type-inference
+from typing import TypeVar, Callable, List
+
+S = TypeVar('S')
+T = TypeVar('T')
+U = TypeVar('U')
+
+def dec(f: Callable[[T], S], g: Callable[[T], int]) -> Callable[[T], List[S]]: ...
+def id(x: U) -> U:
+    ...
+
+reveal_type(dec(id, id))  # N: Revealed type is "def (builtins.int) -> builtins.list[builtins.int]"
+[builtins fixtures/list.pyi]
+
+[case testInferenceAgainstGenericSplitOrderGeneric]
+# flags: --strict-optional --new-type-inference
+from typing import TypeVar, Callable, Tuple
+
+S = TypeVar('S')
+T = TypeVar('T')
+U = TypeVar('U')
+V = TypeVar('V')
+
+def dec(f: Callable[[T], S], g: Callable[[T], U]) -> Callable[[T], Tuple[S, U]]: ...
+def id(x: V) -> V:
+    ...
+
+reveal_type(dec(id, id))  # N: Revealed type is "def [T] (T`1) -> Tuple[T`1, T`1]"
+[builtins fixtures/tuple.pyi]
+
+[case testInferenceAgainstGenericEllipsisSelfSpecialCase]
+# flags: --new-type-inference
+from typing import Self, Callable, TypeVar
+
+T = TypeVar("T")
+def dec(f: Callable[..., T]) -> Callable[..., T]: ...
+
+class C:
+    @dec
+    def test(self) -> Self: ...
+
+c: C
+reveal_type(c.test())  # N: Revealed type is "__main__.C"
diff --git a/test-data/unit/check-parameter-specification.test b/test-data/unit/check-parameter-specification.test
index 901e73008d563..cafcaca0a14ce 100644
--- a/test-data/unit/check-parameter-specification.test
+++ b/test-data/unit/check-parameter-specification.test
@@ -1040,6 +1040,28 @@ reveal_type(jf)  # N: Revealed type is "def [_T] (x: _T`-1)"
 reveal_type(jf(1))  # N: Revealed type is "None"
 [builtins fixtures/paramspec.pyi]
 
+[case testGenericsInInferredParamspecReturn]
+# flags: --new-type-inference
+from typing import Callable, TypeVar, Generic
+from typing_extensions import ParamSpec
+
+_P = ParamSpec("_P")
+_T = TypeVar("_T")
+
+class Job(Generic[_P, _T]):
+    def __init__(self, target: Callable[_P, _T]) -> None: ...
+    def into_callable(self) -> Callable[_P, _T]: ...
+
+def generic_f(x: _T) -> _T: ...
+
+j = Job(generic_f)
+reveal_type(j)  # N: Revealed type is "__main__.Job[[x: _T`-1], _T`-1]"
+
+jf = j.into_callable()
+reveal_type(jf)  # N: Revealed type is "def [_T] (x: _T`-1) -> _T`-1"
+reveal_type(jf(1))  # N: Revealed type is "builtins.int"
+[builtins fixtures/paramspec.pyi]
+
 [case testStackedConcatenateIsIllegal]
 from typing_extensions import Concatenate, ParamSpec
 from typing import Callable
@@ -1520,3 +1542,18 @@ def identity(func: Callable[P, None]) -> Callable[P, None]: ...
 @identity
 def f(f: Callable[P, None], *args: P.args, **kwargs: P.kwargs) -> None: ...
 [builtins fixtures/paramspec.pyi]
+
+[case testParamSpecDecoratorAppliedToGeneric]
+# flags: --new-type-inference
+from typing import Callable, List, TypeVar
+from typing_extensions import ParamSpec
+
+P = ParamSpec("P")
+T = TypeVar("T")
+U = TypeVar("U")
+
+def dec(f: Callable[P, T]) -> Callable[P, List[T]]: ...
+def test(x: U) -> U: ...
+reveal_type(dec)  # N: Revealed type is "def [P, T] (f: def (*P.args, **P.kwargs) -> T`-2) -> def (*P.args, **P.kwargs) -> builtins.list[T`-2]"
+reveal_type(dec(test))  # N: Revealed type is "def [U] (x: U`-1) -> builtins.list[U`-1]"
+[builtins fixtures/paramspec.pyi]
diff --git a/test-data/unit/check-plugin-attrs.test b/test-data/unit/check-plugin-attrs.test
index 9aa31c1ed10ba..5b8c361906a82 100644
--- a/test-data/unit/check-plugin-attrs.test
+++ b/test-data/unit/check-plugin-attrs.test
@@ -1173,12 +1173,13 @@ class A:
 [builtins fixtures/bool.pyi]
 
 [case testAttrsFactoryBadReturn]
+# flags: --new-type-inference
 import attr
 def my_factory() -> int:
     return 7
 @attr.s
 class A:
-    x: int = attr.ib(factory=list)  # E: Incompatible types in assignment (expression has type "List[T]", variable has type "int")
+    x: int = attr.ib(factory=list)  # E: Incompatible types in assignment (expression has type "List[<nothing>]", variable has type "int")
     y: str = attr.ib(factory=my_factory) # E: Incompatible types in assignment (expression has type "int", variable has type "str")
 [builtins fixtures/list.pyi]
 
diff --git a/test-data/unit/pythoneval.test b/test-data/unit/pythoneval.test
index 8c82b6843a3bf..eada8cf6fa85b 100644
--- a/test-data/unit/pythoneval.test
+++ b/test-data/unit/pythoneval.test
@@ -833,6 +833,7 @@ _program.py:3: error: Dict entry 1 has incompatible type "str": "str"; expected
 _program.py:5: error: "Dict[str, int]" has no attribute "xyz"
 
 [case testDefaultDict]
+# flags: --new-type-inference
 import typing as t
 from collections import defaultdict
 
@@ -858,11 +859,11 @@ class MyDDict(t.DefaultDict[int,T], t.Generic[T]):
 MyDDict(dict)['0']
 MyDDict(dict)[0]
 [out]
-_program.py:6: error: Argument 1 to "defaultdict" has incompatible type "Type[List[Any]]"; expected "Callable[[], str]"
-_program.py:9: error: Invalid index type "str" for "defaultdict[int, str]"; expected type "int"
-_program.py:9: error: Incompatible types in assignment (expression has type "int", target has type "str")
-_program.py:19: error: Argument 1 to "tst" has incompatible type "defaultdict[str, List[<nothing>]]"; expected "defaultdict[int, List[<nothing>]]"
-_program.py:23: error: Invalid index type "str" for "MyDDict[Dict[_KT, _VT]]"; expected type "int"
+_program.py:7: error: Argument 1 to "defaultdict" has incompatible type "Type[List[Any]]"; expected "Callable[[], str]"
+_program.py:10: error: Invalid index type "str" for "defaultdict[int, str]"; expected type "int"
+_program.py:10: error: Incompatible types in assignment (expression has type "int", target has type "str")
+_program.py:20: error: Argument 1 to "tst" has incompatible type "defaultdict[str, List[<nothing>]]"; expected "defaultdict[int, List[<nothing>]]"
+_program.py:24: error: Invalid index type "str" for "MyDDict[Dict[<nothing>, <nothing>]]"; expected type "int"
 
 [case testNoSubcriptionOfStdlibCollections]
 # flags: --python-version 3.6
@@ -2032,7 +2033,6 @@ from dataclasses import dataclass, replace
 class A:
     x: int
 
-
 a = A(x=42)
 a2 = replace(a, x=42)
 reveal_type(a2)
@@ -2040,7 +2040,47 @@ a2 = replace()
 a2 = replace(a, x='spam')
 a2 = replace(a, x=42, q=42)
 [out]
-_testDataclassReplace.py:10: note: Revealed type is "_testDataclassReplace.A"
-_testDataclassReplace.py:11: error: Too few arguments for "replace"
-_testDataclassReplace.py:12: error: Argument "x" to "replace" of "A" has incompatible type "str"; expected "int"
-_testDataclassReplace.py:13: error: Unexpected keyword argument "q" for "replace" of "A"
+_testDataclassReplace.py:9: note: Revealed type is "_testDataclassReplace.A"
+_testDataclassReplace.py:10: error: Too few arguments for "replace"
+_testDataclassReplace.py:11: error: Argument "x" to "replace" of "A" has incompatible type "str"; expected "int"
+_testDataclassReplace.py:12: error: Unexpected keyword argument "q" for "replace" of "A"
+
+[case testGenericInferenceWithTuple]
+# flags: --new-type-inference
+from typing import TypeVar, Callable, Tuple
+
+T = TypeVar("T")
+
+def f(x: Callable[..., T]) -> T:
+    return x()
+
+x: Tuple[str, ...] = f(tuple)
+[out]
+
+[case testGenericInferenceWithDataclass]
+# flags: --new-type-inference
+from typing import Any, Collection, List
+from dataclasses import dataclass, field
+
+class Foo:
+    pass
+
+@dataclass
+class A:
+    items: Collection[Foo] = field(default_factory=list)
+[out]
+
+[case testGenericInferenceWithItertools]
+# flags: --new-type-inference
+from typing import TypeVar, Tuple
+from itertools import groupby
+K = TypeVar("K")
+V = TypeVar("V")
+
+def fst(kv: Tuple[K, V]) -> K:
+    k, v = kv
+    return k
+
+pairs = [(len(s), s) for s in ["one", "two", "three"]]
+grouped = groupby(pairs, key=fst)
+[out]

From 32d14ed9928f04bdbd70b6381c5706024dfb4e70 Mon Sep 17 00:00:00 2001
From: Ivan Levkivskyi <levkivskyi@gmail.com>
Date: Mon, 19 Jun 2023 11:01:12 +0100
Subject: [PATCH 047/129] Delete a ProperType join hack (#15461)

The tests added with this piece of code now pass even without it. It
looks like the crash was properly fixed by
https://github.com/python/mypy/pull/13371
---
 mypy/join.py | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/mypy/join.py b/mypy/join.py
index 62d256f4440f9..f4af59f4e50b6 100644
--- a/mypy/join.py
+++ b/mypy/join.py
@@ -29,7 +29,6 @@
     Parameters,
     ParamSpecType,
     PartialType,
-    PlaceholderType,
     ProperType,
     TupleType,
     Type,
@@ -246,14 +245,6 @@ def join_types(s: Type, t: Type, instance_joiner: InstanceJoiner | None = None)
     if isinstance(s, UninhabitedType) and not isinstance(t, UninhabitedType):
         s, t = t, s
 
-    # We shouldn't run into PlaceholderTypes here, but in practice we can encounter them
-    # here in the presence of undefined names
-    if isinstance(t, PlaceholderType) and not isinstance(s, PlaceholderType):
-        # mypyc does not allow switching the values like above.
-        return s.accept(TypeJoinVisitor(t))
-    elif isinstance(t, PlaceholderType):
-        return AnyType(TypeOfAny.from_error)
-
     # Meets/joins require callable type normalization.
     s, t = normalize_callables(s, t)
 

From 719e7e77a52d30146de3a95ee2b6baf69a11eb17 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Mon, 19 Jun 2023 12:34:07 +0100
Subject: [PATCH 048/129] [mypyc] Add Python 3.12 feature macro (#15465)

It's currently unused but I have other PRs that will need this.

We can later make this more general and support things like "are we
running on Python 3.12 beta 2 or later", but this seems good enough for
now.
---
 mypyc/lib-rt/mypyc_util.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/mypyc/lib-rt/mypyc_util.h b/mypyc/lib-rt/mypyc_util.h
index 13672087fbbcf..3bc785ac6526b 100644
--- a/mypyc/lib-rt/mypyc_util.h
+++ b/mypyc/lib-rt/mypyc_util.h
@@ -69,4 +69,7 @@ static inline CPyTagged CPyTagged_ShortFromSsize_t(Py_ssize_t x) {
     return x << 1;
 }
 
+// Are we targeting Python 3.12 or newer?
+#define CPY_3_12_FEATURES (PY_VERSION_HEX >= 0x030c0000)
+
 #endif

From c0e6d2818bcab9a7313cebb54463d752004de844 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Mon, 19 Jun 2023 23:42:19 +0100
Subject: [PATCH 049/129] [mypyc] Don't use _PyErr_ChainExceptions on 3.12,
 since it's deprecated (#15468)

---
 mypyc/lib-rt/exc_ops.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/mypyc/lib-rt/exc_ops.c b/mypyc/lib-rt/exc_ops.c
index 219914bf34702..a7536994d0594 100644
--- a/mypyc/lib-rt/exc_ops.c
+++ b/mypyc/lib-rt/exc_ops.c
@@ -230,7 +230,11 @@ void CPy_AddTraceback(const char *filename, const char *funcname, int line, PyOb
     return;
 
 error:
+#if CPY_3_12_FEATURES
+    _PyErr_ChainExceptions1(exc);
+#else
     _PyErr_ChainExceptions(exc, val, tb);
+#endif
 }
 
 CPy_NOINLINE

From 6907343e0191162aa03cc21d23489606e0997b4a Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Mon, 19 Jun 2023 23:43:39 +0100
Subject: [PATCH 050/129] [mypyc] Fix gen_is_coroutine on Python 3.12 (#15469)

---
 mypyc/lib-rt/pythonsupport.h | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/mypyc/lib-rt/pythonsupport.h b/mypyc/lib-rt/pythonsupport.h
index 8a1159a988538..6751f6f4af02d 100644
--- a/mypyc/lib-rt/pythonsupport.h
+++ b/mypyc/lib-rt/pythonsupport.h
@@ -13,6 +13,10 @@
 #include <assert.h>
 #include "mypyc_util.h"
 
+#if CPY_3_12_FEATURES
+#include "internal/pycore_frame.h"
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -389,6 +393,31 @@ _CPyObject_HasAttrId(PyObject *v, _Py_Identifier *name) {
     _PyObject_CallMethodIdObjArgs((self), (name), (arg), NULL)
 #endif
 
+#if CPY_3_12_FEATURES
+
+// These are copied from genobject.c in Python 3.12
+
+/* Returns a borrowed reference */
+static inline PyCodeObject *
+_PyGen_GetCode(PyGenObject *gen) {
+    _PyInterpreterFrame *frame = (_PyInterpreterFrame *)(gen->gi_iframe);
+    return frame->f_code;
+}
+
+static int
+gen_is_coroutine(PyObject *o)
+{
+    if (PyGen_CheckExact(o)) {
+        PyCodeObject *code = _PyGen_GetCode((PyGenObject*)o);
+        if (code->co_flags & CO_ITERABLE_COROUTINE) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+#else
+
 // Copied from genobject.c in Python 3.10
 static int
 gen_is_coroutine(PyObject *o)
@@ -402,6 +431,8 @@ gen_is_coroutine(PyObject *o)
     return 0;
 }
 
+#endif
+
 /*
  *   This helper function returns an awaitable for `o`:
  *     - `o` if `o` is a coroutine-object;

From d1fe7cf849dbdf2b41109db1ce5fc6293ce6ec0a Mon Sep 17 00:00:00 2001
From: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
Date: Mon, 19 Jun 2023 16:06:05 -0700
Subject: [PATCH 051/129] [minor] Use keyword-only args for ErrorInfo (#15473)

---
 mypy/errors.py | 113 +++++++++++++++++++++++++------------------------
 1 file changed, 57 insertions(+), 56 deletions(-)

diff --git a/mypy/errors.py b/mypy/errors.py
index 9d29259e943c1..b230b3baa3f6f 100644
--- a/mypy/errors.py
+++ b/mypy/errors.py
@@ -90,6 +90,7 @@ class ErrorInfo:
     def __init__(
         self,
         import_ctx: list[tuple[str, int]],
+        *,
         file: str,
         module: str | None,
         typ: str | None,
@@ -415,21 +416,21 @@ def report(
         code = code or (codes.MISC if not blocker else None)
 
         info = ErrorInfo(
-            self.import_context(),
-            file,
-            self.current_module(),
-            type,
-            function,
-            line,
-            column,
-            end_line,
-            end_column,
-            severity,
-            message,
-            code,
-            blocker,
-            only_once,
-            allow_dups,
+            import_ctx=self.import_context(),
+            file=file,
+            module=self.current_module(),
+            typ=type,
+            function_or_member=function,
+            line=line,
+            column=column,
+            end_line=end_line,
+            end_column=end_column,
+            severity=severity,
+            message=message,
+            code=code,
+            blocker=blocker,
+            only_once=only_once,
+            allow_dups=allow_dups,
             origin=(self.file, origin_span),
             target=self.current_target(),
         )
@@ -511,17 +512,17 @@ def add_error_info(self, info: ErrorInfo) -> None:
                         + "may be out of date"
                     )
             note = ErrorInfo(
-                info.import_ctx,
-                info.file,
-                info.module,
-                info.type,
-                info.function_or_member,
-                info.line,
-                info.column,
-                info.end_line,
-                info.end_column,
-                "note",
-                msg,
+                import_ctx=info.import_ctx,
+                file=info.file,
+                module=info.module,
+                typ=info.type,
+                function_or_member=info.function_or_member,
+                line=info.line,
+                column=info.column,
+                end_line=info.end_line,
+                end_column=info.end_column,
+                severity="note",
+                message=msg,
                 code=None,
                 blocker=False,
                 only_once=False,
@@ -653,21 +654,21 @@ def generate_unused_ignore_errors(self, file: str) -> None:
                     message += f", use narrower [{', '.join(narrower)}] instead of [{unused}] code"
             # Don't use report since add_error_info will ignore the error!
             info = ErrorInfo(
-                self.import_context(),
-                file,
-                self.current_module(),
-                None,
-                None,
-                line,
-                -1,
-                line,
-                -1,
-                "error",
-                message,
-                codes.UNUSED_IGNORE,
-                False,
-                False,
-                False,
+                import_ctx=self.import_context(),
+                file=file,
+                module=self.current_module(),
+                typ=None,
+                function_or_member=None,
+                line=line,
+                column=-1,
+                end_line=line,
+                end_column=-1,
+                severity="error",
+                message=message,
+                code=codes.UNUSED_IGNORE,
+                blocker=False,
+                only_once=False,
+                allow_dups=False,
             )
             self._add_error_info(file, info)
 
@@ -705,21 +706,21 @@ def generate_ignore_without_code_errors(
             message = f'"type: ignore" comment without error code{codes_hint}'
             # Don't use report since add_error_info will ignore the error!
             info = ErrorInfo(
-                self.import_context(),
-                file,
-                self.current_module(),
-                None,
-                None,
-                line,
-                -1,
-                line,
-                -1,
-                "error",
-                message,
-                codes.IGNORE_WITHOUT_CODE,
-                False,
-                False,
-                False,
+                import_ctx=self.import_context(),
+                file=file,
+                module=self.current_module(),
+                typ=None,
+                function_or_member=None,
+                line=line,
+                column=-1,
+                end_line=line,
+                end_column=-1,
+                severity="error",
+                message=message,
+                code=codes.IGNORE_WITHOUT_CODE,
+                blocker=False,
+                only_once=False,
+                allow_dups=False,
             )
             self._add_error_info(file, info)
 

From 15f210b104c253e866b50607126c7022258bd715 Mon Sep 17 00:00:00 2001
From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
Date: Tue, 20 Jun 2023 07:23:40 +0200
Subject: [PATCH 052/129] Enable strict optional for pythoneval tests (#15474)

---
 mypy/test/testpythoneval.py    |   2 -
 test-data/unit/pythoneval.test | 106 ++++++++++++++++++---------------
 2 files changed, 57 insertions(+), 51 deletions(-)

diff --git a/mypy/test/testpythoneval.py b/mypy/test/testpythoneval.py
index 1fd342452102b..17baec96cfbc9 100644
--- a/mypy/test/testpythoneval.py
+++ b/mypy/test/testpythoneval.py
@@ -46,10 +46,8 @@ def test_python_evaluation(testcase: DataDrivenTestCase, cache_dir: str) -> None
     """
     assert testcase.old_cwd is not None, "test was not properly set up"
     # We must enable site packages to get access to installed stubs.
-    # TODO: Enable strict optional for these tests
     mypy_cmdline = [
         "--show-traceback",
-        "--no-strict-optional",
         "--no-silence-site-packages",
         "--no-error-summary",
         "--hide-error-codes",
diff --git a/test-data/unit/pythoneval.test b/test-data/unit/pythoneval.test
index eada8cf6fa85b..b43dcbd7088fb 100644
--- a/test-data/unit/pythoneval.test
+++ b/test-data/unit/pythoneval.test
@@ -63,8 +63,8 @@ print(abs(A()))
 5.5
 
 [case testAbs2]
-n = None  # type: int
-f = None  # type: float
+n: int
+f: float
 n = abs(1)
 abs(1) + 'x'  # Error
 f = abs(1.1)
@@ -95,7 +95,7 @@ print(list.__add__([1, 2], [3, 4]))
 import typing
 class A:
     x = 1
-    def f(self) -> None: print('f')
+    def f(self: typing.Optional["A"]) -> None: print('f')
 class B(A):
     pass
 B.f(None)
@@ -130,7 +130,7 @@ A docstring!
 [case testFunctionAttributes]
 import typing
 ord.__class__
-print(type(ord.__doc__ + ''))
+print(type(ord.__doc__ or '' + ''))
 print(ord.__name__)
 print(ord.__module__)
 [out]
@@ -333,25 +333,28 @@ _program.py:6: note: Revealed type is "typing.IO[Any]"
 [case testGenericPatterns]
 from typing import Pattern
 import re
-p = None  # type: Pattern[str]
+p: Pattern[str]
 p = re.compile('foo*')
-b = None  # type: Pattern[bytes]
+b: Pattern[bytes]
 b = re.compile(b'foo*')
-print(p.match('fooo').group(0))
+m = p.match('fooo')
+assert m
+print(m.group(0))
 [out]
 fooo
 
 [case testGenericMatch]
-from typing import Match
+from typing import Match, Optional
 import re
-def f(m: Match[bytes]) -> None:
+def f(m: Optional[Match[bytes]]) -> None:
+    assert m
     print(m.group(0))
 f(re.match(b'x*', b'xxy'))
 [out]
 b'xx'
 
 [case testIntFloatDucktyping]
-x = None  # type: float
+x: float
 x = 2.2
 x = 2
 def f(x: float) -> None: pass
@@ -374,18 +377,17 @@ math.sin(2)
 math.sin(2.2)
 
 [case testAbsReturnType]
-
-f = None  # type: float
-n = None  # type: int
+f: float
+n: int
 n = abs(2)
 f = abs(2.2)
 abs(2.2) + 'x'
 [out]
-_program.py:6: error: Unsupported operand types for + ("float" and "str")
+_program.py:5: error: Unsupported operand types for + ("float" and "str")
 
 [case testROperatorMethods]
-b = None  # type: bytes
-s = None  # type: str
+b: bytes
+s: str
 if int():
     s = b'foo' * 5 # Error
 if int():
@@ -434,7 +436,6 @@ True
 False
 
 [case testOverlappingOperatorMethods]
-
 class X: pass
 class A:
     def __add__(self, x) -> int:
@@ -444,11 +445,11 @@ class A:
 class B:
     def __radd__(self, x: A) -> str: return 'x'
 class C(X, B): pass
-b = None  # type: B
+b: B
 b = C()
 print(A() + b)
 [out]
-_program.py:9: error: Signatures of "__radd__" of "B" and "__add__" of "A" are unsafely overlapping
+_program.py:8: error: Signatures of "__radd__" of "B" and "__add__" of "A" are unsafely overlapping
 
 [case testBytesAndBytearrayComparisons]
 import typing
@@ -859,7 +860,7 @@ class MyDDict(t.DefaultDict[int,T], t.Generic[T]):
 MyDDict(dict)['0']
 MyDDict(dict)[0]
 [out]
-_program.py:7: error: Argument 1 to "defaultdict" has incompatible type "Type[List[Any]]"; expected "Callable[[], str]"
+_program.py:7: error: Argument 1 to "defaultdict" has incompatible type "Type[List[Any]]"; expected "Optional[Callable[[], str]]"
 _program.py:10: error: Invalid index type "str" for "defaultdict[int, str]"; expected type "int"
 _program.py:10: error: Incompatible types in assignment (expression has type "int", target has type "str")
 _program.py:20: error: Argument 1 to "tst" has incompatible type "defaultdict[str, List[<nothing>]]"; expected "defaultdict[int, List[<nothing>]]"
@@ -966,10 +967,10 @@ print(getattr(B(), 'x'))
 7
 
 [case testSortedNoError]
-from typing import Iterable, Callable, TypeVar, List, Dict
+from typing import Iterable, Callable, TypeVar, List, Dict, Optional
 T = TypeVar('T')
-def sorted(x: Iterable[T], *, key: Callable[[T], object] = None) -> None: ...
-a = None # type: List[Dict[str, str]]
+def sorted(x: Iterable[T], *, key: Optional[Callable[[T], object]] = None) -> None: ...
+a = []  # type: List[Dict[str, str]]
 sorted(a, key=lambda y: y[''])
 
 [case testAbstractProperty]
@@ -1002,9 +1003,13 @@ import re
 bre = b'a+'
 bpat = re.compile(bre)
 bpat = re.compile(bpat)
-re.search(bre, b'').groups()
+s1 = re.search(bre, b'')
+assert s1
+s1.groups()
 re.search(bre, u'') # Error
-re.search(bpat, b'').groups()
+s2 = re.search(bpat, b'')
+assert s2
+s2.groups()
 re.search(bpat, u'') # Error
 # match(), split(), findall(), finditer() are much the same, so skip those.
 # sub(), subn() have more overloads and we are checking these:
@@ -1017,11 +1022,11 @@ re.subn(bpat, b'', b'')[0] + b''
 re.subn(bre, lambda m: b'', b'')[0] + b''
 re.subn(bpat, lambda m: b'', b'')[0] + b''
 [out]
-_testReModuleBytes.py:7: error: No overload variant of "search" matches argument types "bytes", "str"
-_testReModuleBytes.py:7: note: Possible overload variants:
-_testReModuleBytes.py:7: note:     def search(pattern: Union[str, Pattern[str]], string: str, flags: Union[int, RegexFlag] = ...) -> Optional[Match[str]]
-_testReModuleBytes.py:7: note:     def search(pattern: Union[bytes, Pattern[bytes]], string: Buffer, flags: Union[int, RegexFlag] = ...) -> Optional[Match[bytes]]
-_testReModuleBytes.py:9: error: Argument 1 to "search" has incompatible type "Pattern[bytes]"; expected "Union[str, Pattern[str]]"
+_testReModuleBytes.py:9: error: No overload variant of "search" matches argument types "bytes", "str"
+_testReModuleBytes.py:9: note: Possible overload variants:
+_testReModuleBytes.py:9: note:     def search(pattern: Union[str, Pattern[str]], string: str, flags: Union[int, RegexFlag] = ...) -> Optional[Match[str]]
+_testReModuleBytes.py:9: note:     def search(pattern: Union[bytes, Pattern[bytes]], string: Buffer, flags: Union[int, RegexFlag] = ...) -> Optional[Match[bytes]]
+_testReModuleBytes.py:13: error: Argument 1 to "search" has incompatible type "Pattern[bytes]"; expected "Union[str, Pattern[str]]"
 
 [case testReModuleString]
 # Regression tests for various overloads in the re module -- string version
@@ -1029,9 +1034,13 @@ import re
 sre = 'a+'
 spat = re.compile(sre)
 spat = re.compile(spat)
-re.search(sre, '').groups()
+s1 = re.search(sre, '')
+assert s1
+s1.groups()
 re.search(sre, b'') # Error
-re.search(spat, '').groups()
+s2 = re.search(spat, '')
+assert s2
+s2.groups()
 re.search(spat, b'') # Error
 # match(), split(), findall(), finditer() are much the same, so skip those.
 # sus(), susn() have more overloads and we are checking these:
@@ -1044,11 +1053,11 @@ re.subn(spat, '', '')[0] + ''
 re.subn(sre, lambda m: '', '')[0] + ''
 re.subn(spat, lambda m: '', '')[0] + ''
 [out]
-_testReModuleString.py:7: error: No overload variant of "search" matches argument types "str", "bytes"
-_testReModuleString.py:7: note: Possible overload variants:
-_testReModuleString.py:7: note:     def search(pattern: Union[str, Pattern[str]], string: str, flags: Union[int, RegexFlag] = ...) -> Optional[Match[str]]
-_testReModuleString.py:7: note:     def search(pattern: Union[bytes, Pattern[bytes]], string: Buffer, flags: Union[int, RegexFlag] = ...) -> Optional[Match[bytes]]
-_testReModuleString.py:9: error: Argument 1 to "search" has incompatible type "Pattern[str]"; expected "Union[bytes, Pattern[bytes]]"
+_testReModuleString.py:9: error: No overload variant of "search" matches argument types "str", "bytes"
+_testReModuleString.py:9: note: Possible overload variants:
+_testReModuleString.py:9: note:     def search(pattern: Union[str, Pattern[str]], string: str, flags: Union[int, RegexFlag] = ...) -> Optional[Match[str]]
+_testReModuleString.py:9: note:     def search(pattern: Union[bytes, Pattern[bytes]], string: Buffer, flags: Union[int, RegexFlag] = ...) -> Optional[Match[bytes]]
+_testReModuleString.py:13: error: Argument 1 to "search" has incompatible type "Pattern[str]"; expected "Union[bytes, Pattern[bytes]]"
 
 [case testListSetitemTuple]
 from typing import List, Tuple
@@ -1085,7 +1094,6 @@ _program.py:17: note: Revealed type is "builtins.str"
 
 [case testTypedDictGet]
 # Test that TypedDict get plugin works with typeshed stubs
-# TODO: Make it possible to use strict optional here
 from mypy_extensions import TypedDict
 class A: pass
 D = TypedDict('D', {'x': int, 'y': str})
@@ -1097,14 +1105,14 @@ d.get()
 s = ''
 reveal_type(d.get(s))
 [out]
-_testTypedDictGet.py:7: note: Revealed type is "builtins.int"
-_testTypedDictGet.py:8: note: Revealed type is "builtins.str"
-_testTypedDictGet.py:9: note: Revealed type is "builtins.object"
-_testTypedDictGet.py:10: error: All overload variants of "get" of "Mapping" require at least one argument
-_testTypedDictGet.py:10: note: Possible overload variants:
-_testTypedDictGet.py:10: note:     def get(self, str, /) -> object
-_testTypedDictGet.py:10: note:     def [_T] get(self, str, /, default: object) -> object
-_testTypedDictGet.py:12: note: Revealed type is "builtins.object"
+_testTypedDictGet.py:6: note: Revealed type is "Union[builtins.int, None]"
+_testTypedDictGet.py:7: note: Revealed type is "Union[builtins.str, None]"
+_testTypedDictGet.py:8: note: Revealed type is "builtins.object"
+_testTypedDictGet.py:9: error: All overload variants of "get" of "Mapping" require at least one argument
+_testTypedDictGet.py:9: note: Possible overload variants:
+_testTypedDictGet.py:9: note:     def get(self, str, /) -> object
+_testTypedDictGet.py:9: note:     def [_T] get(self, str, /, default: object) -> object
+_testTypedDictGet.py:11: note: Revealed type is "builtins.object"
 
 [case testTypedDictMappingMethods]
 from mypy_extensions import TypedDict
@@ -1143,10 +1151,10 @@ _testTypedDictMappingMethods.py:16: error: Key "value" of TypedDict "Cell" canno
 _testTypedDictMappingMethods.py:21: note: Revealed type is "builtins.int"
 
 [case testCrashOnComplexCheckWithNamedTupleNext]
-from typing import NamedTuple
+from typing import NamedTuple, Optional
 
 MyNamedTuple = NamedTuple('MyNamedTuple', [('parent', 'MyNamedTuple')]) # type: ignore
-def foo(mymap) -> MyNamedTuple:
+def foo(mymap) -> Optional[MyNamedTuple]:
     return next((mymap[key] for key in mymap), None)
 [out]
 
@@ -1374,7 +1382,7 @@ JsonBlob = Dict[str, Any]
 Column = Union[List[str], List[int], List[bool], List[float], List[DateTime], List[JsonBlob]]
 
 def print_custom_table() -> None:
-    a = None  # type: Column
+    a: Column
 
     for row in simple_map(format_row, a, a, a, a, a, a, a, a):  # 8 columns
         reveal_type(row)

From 7d5213d0c3490ab03ed5240f9a02dd95dd002793 Mon Sep 17 00:00:00 2001
From: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
Date: Tue, 20 Jun 2023 00:31:20 -0700
Subject: [PATCH 053/129] Use setuptools instead of distutils in docs (#15477)

---
 docs/source/installed_packages.rst | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/docs/source/installed_packages.rst b/docs/source/installed_packages.rst
index b9a3b891c99cb..fa4fae1a0b3e5 100644
--- a/docs/source/installed_packages.rst
+++ b/docs/source/installed_packages.rst
@@ -119,7 +119,7 @@ The ``setup.py`` file could look like this:
 
 .. code-block:: python
 
-    from distutils.core import setup
+    from setuptools import setup
 
     setup(
         name="SuperPackageA",
@@ -129,11 +129,6 @@ The ``setup.py`` file could look like this:
         packages=["package_a"]
     )
 
-.. note::
-
-   If you use :doc:`setuptools <setuptools:index>`, you must pass the option ``zip_safe=False`` to
-   ``setup()``, or mypy will not be able to find the installed package.
-
 Some packages have a mix of stub files and runtime files. These packages also
 require a ``py.typed`` file. An example can be seen below:
 
@@ -150,7 +145,7 @@ The ``setup.py`` file might look like this:
 
 .. code-block:: python
 
-    from distutils.core import setup
+    from setuptools import setup
 
     setup(
         name="SuperPackageB",
@@ -180,7 +175,7 @@ The ``setup.py`` might look like this:
 
 .. code-block:: python
 
-    from distutils.core import setup
+    from setuptools import setup
 
     setup(
         name="SuperPackageC",

From 1e5caa0dc349750c3eb6c5f448c7aab524e3ec38 Mon Sep 17 00:00:00 2001
From: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
Date: Tue, 20 Jun 2023 01:32:34 -0700
Subject: [PATCH 054/129] Remove test failing on 3.12 (#15478)

---
 test-data/unit/check-newsyntax.test | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/test-data/unit/check-newsyntax.test b/test-data/unit/check-newsyntax.test
index 63284c34bd8bc..cfcbfc598c514 100644
--- a/test-data/unit/check-newsyntax.test
+++ b/test-data/unit/check-newsyntax.test
@@ -105,11 +105,6 @@ main:5: error: "str" has no attribute "x"
 async def f():
     results = [i async for i in aiter() if i % 2]  # E: Async comprehensions are only supported in Python 3.6 and greater
 
-
-[case testNewSyntaxFstringError]
-# flags: --python-version 3.5
-f''  # E: Format strings are only supported in Python 3.6 and greater
-
 [case testNewSyntaxFStringBasics]
 # flags: --python-version 3.6
 f'foobar'

From e3210d07d945bd7b120dd0d6f20036ed664c4129 Mon Sep 17 00:00:00 2001
From: Ilya Priven <ilya.konstantinov@gmail.com>
Date: Tue, 20 Jun 2023 09:41:26 -0400
Subject: [PATCH 055/129] meta tests: fix flake (#15480)

Since tests are parallelized, the temporary test name must be unique.
---
 mypy/test/meta/test_parse_data.py  | 3 ++-
 mypy/test/meta/test_update_data.py | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/mypy/test/meta/test_parse_data.py b/mypy/test/meta/test_parse_data.py
index a74b3d71d392b..cc1b4ff6eeed5 100644
--- a/mypy/test/meta/test_parse_data.py
+++ b/mypy/test/meta/test_parse_data.py
@@ -5,6 +5,7 @@
 import subprocess
 import sys
 import textwrap
+import uuid
 from pathlib import Path
 
 from mypy.test.config import test_data_prefix
@@ -18,7 +19,7 @@ def _dedent(self, s: str) -> str:
     def _run_pytest(self, data_suite: str) -> str:
         p_test_data = Path(test_data_prefix)
         p_root = p_test_data.parent.parent
-        p = p_test_data / "check-__fixture__.test"
+        p = p_test_data / f"check-meta-{uuid.uuid4()}.test"
         assert not p.exists()
         try:
             p.write_text(data_suite)
diff --git a/mypy/test/meta/test_update_data.py b/mypy/test/meta/test_update_data.py
index 1239679072e61..67f9a7f56ebd2 100644
--- a/mypy/test/meta/test_update_data.py
+++ b/mypy/test/meta/test_update_data.py
@@ -7,6 +7,7 @@
 import subprocess
 import sys
 import textwrap
+import uuid
 from pathlib import Path
 
 from mypy.test.config import test_data_prefix
@@ -21,7 +22,7 @@ def _run_pytest_update_data(self, data_suite: str, *, max_attempts: int) -> str:
         """
         p_test_data = Path(test_data_prefix)
         p_root = p_test_data.parent.parent
-        p = p_test_data / "check-__fixture__.test"
+        p = p_test_data / f"check-meta-{uuid.uuid4()}.test"
         assert not p.exists()
         try:
             p.write_text(textwrap.dedent(data_suite).lstrip())

From 304997bfb85200fb521ac727ee0ce3e6085e5278 Mon Sep 17 00:00:00 2001
From: Logan Hunt <39638017+dosisod@users.noreply.github.com>
Date: Tue, 20 Jun 2023 16:25:38 -0700
Subject: [PATCH 056/129] Switch from `flake8` to `ruff` (#15362)

---
 .github/workflows/test.yml  |  2 +-
 .gitignore                  |  1 -
 .pre-commit-config.yaml     | 13 +++--------
 CONTRIBUTING.md             |  2 +-
 mypy/build.py               |  4 ++--
 mypy/plugins/common.py      |  4 +---
 mypy/server/objgraph.py     |  4 ++--
 mypy/typeanal.py            |  2 +-
 mypy/types.py               |  2 +-
 mypyc/irbuild/specialize.py |  2 +-
 pyproject.toml              | 37 +++++++++++++++++++++++++++++++
 setup.cfg                   | 43 -------------------------------------
 test-data/.flake8           | 22 -------------------
 test-data/unit/README.md    |  2 +-
 test-requirements.txt       |  4 +---
 15 files changed, 52 insertions(+), 92 deletions(-)
 delete mode 100644 test-data/.flake8

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 81587f3ca7476..6fc8fb11c6f43 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -96,7 +96,7 @@ jobs:
           # We also run these checks with pre-commit in CI,
           # but it's useful to run them with tox too,
           # to ensure the tox env works as expected
-        - name: Formatting with Black + isort and code style with flake8
+        - name: Formatting with Black + isort and code style with ruff
           python: '3.10'
           arch: x64
           os: ubuntu-latest
diff --git a/.gitignore b/.gitignore
index c6761f0ed7365..6c35e3d89342d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -57,6 +57,5 @@ test_capi
 *.o
 *.a
 test_capi
-/.mypyc-flake8-cache.json
 /mypyc/lib-rt/build/
 /mypyc/lib-rt/*.so
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 92d827fba006f..cbb3672bd9865 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -13,14 +13,7 @@ repos:
     rev: 5.12.0  # must match test-requirements.txt
     hooks:
       - id: isort
-  - repo: https://github.com/pycqa/flake8
-    rev: 6.0.0  # must match test-requirements.txt
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.0.272  # must match test-requirements.txt
     hooks:
-      - id: flake8
-        additional_dependencies:
-          - flake8-bugbear==23.3.23  # must match test-requirements.txt
-          - flake8-noqa==1.3.1       # must match test-requirements.txt
-
-ci:
-  # We run flake8 as part of our GitHub Actions suite in CI
-  skip: [flake8]
+      - id: ruff
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index d169d7f3159ec..99ba2f8c9a766 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -89,7 +89,7 @@ pytest -n0 -k 'test_name'
 pytest mypy/test/testcheck.py::TypeCheckSuite::check-dataclasses.test
 
 # Run the linter
-flake8
+ruff .
 
 # Run formatters
 black . && isort .
diff --git a/mypy/build.py b/mypy/build.py
index 2f556120d4303..f388f09098546 100644
--- a/mypy/build.py
+++ b/mypy/build.py
@@ -3076,7 +3076,7 @@ def load_graph(
             manager.errors.report(
                 -1,
                 -1,
-                "See https://mypy.readthedocs.io/en/stable/running_mypy.html#mapping-file-paths-to-modules "  # noqa: E501
+                "See https://mypy.readthedocs.io/en/stable/running_mypy.html#mapping-file-paths-to-modules "
                 "for more info",
                 severity="note",
             )
@@ -3164,7 +3164,7 @@ def load_graph(
                             manager.errors.report(
                                 -1,
                                 0,
-                                "See https://mypy.readthedocs.io/en/stable/running_mypy.html#mapping-file-paths-to-modules "  # noqa: E501
+                                "See https://mypy.readthedocs.io/en/stable/running_mypy.html#mapping-file-paths-to-modules "
                                 "for more info",
                                 severity="note",
                             )
diff --git a/mypy/plugins/common.py b/mypy/plugins/common.py
index f803387cde8b3..65d967577beac 100644
--- a/mypy/plugins/common.py
+++ b/mypy/plugins/common.py
@@ -28,9 +28,7 @@
     require_bool_literal_argument,
     set_callable_name,
 )
-from mypy.typeops import (  # noqa: F401  # Part of public API
-    try_getting_str_literals as try_getting_str_literals,
-)
+from mypy.typeops import try_getting_str_literals as try_getting_str_literals
 from mypy.types import (
     AnyType,
     CallableType,
diff --git a/mypy/server/objgraph.py b/mypy/server/objgraph.py
index 89a086b8a0ab2..37d0f4d2ca1a2 100644
--- a/mypy/server/objgraph.py
+++ b/mypy/server/objgraph.py
@@ -46,7 +46,7 @@ def get_edge_candidates(o: object) -> Iterator[tuple[object, object]]:
             try:
                 if attr not in ATTR_BLACKLIST and hasattr(o, attr) and not isproperty(o, attr):
                     e = getattr(o, attr)
-                    if not type(e) in ATOMIC_TYPE_BLACKLIST:
+                    if type(e) not in ATOMIC_TYPE_BLACKLIST:
                         yield attr, e
             except AssertionError:
                 pass
@@ -70,7 +70,7 @@ def get_edges(o: object) -> Iterator[tuple[object, object]]:
                 if se is not o and se is not type(o) and hasattr(s, "__self__"):
                     yield s.__self__, se
         else:
-            if not type(e) in TYPE_BLACKLIST:
+            if type(e) not in TYPE_BLACKLIST:
                 yield s, e
 
 
diff --git a/mypy/typeanal.py b/mypy/typeanal.py
index 39a44a2893659..d577f355dbc8f 100644
--- a/mypy/typeanal.py
+++ b/mypy/typeanal.py
@@ -1256,7 +1256,7 @@ def analyze_callable_type(self, t: UnboundType) -> Type:
                         code=codes.VALID_TYPE,
                     )
                     self.note(
-                        "See https://mypy.readthedocs.io/en/stable/kinds_of_types.html#callable-types-and-lambdas",  # noqa: E501
+                        "See https://mypy.readthedocs.io/en/stable/kinds_of_types.html#callable-types-and-lambdas",
                         t,
                     )
                     return AnyType(TypeOfAny.from_error)
diff --git a/mypy/types.py b/mypy/types.py
index e4c22da12603e..25bfdd8b03c47 100644
--- a/mypy/types.py
+++ b/mypy/types.py
@@ -2957,7 +2957,7 @@ def get_proper_types(
 # to make it easier to gradually get modules working with mypyc.
 # Import them here, after the types are defined.
 # This is intended as a re-export also.
-from mypy.type_visitor import (  # noqa: F811,F401
+from mypy.type_visitor import (  # noqa: F811
     ALL_STRATEGY as ALL_STRATEGY,
     ANY_STRATEGY as ANY_STRATEGY,
     BoolTypeQuery as BoolTypeQuery,
diff --git a/mypyc/irbuild/specialize.py b/mypyc/irbuild/specialize.py
index ff9df0cd597b0..14a6f8e92df2d 100644
--- a/mypyc/irbuild/specialize.py
+++ b/mypyc/irbuild/specialize.py
@@ -446,7 +446,7 @@ def translate_sum_call(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> V
     # handle 'start' argument, if given
     if len(expr.args) == 2:
         # ensure call to sum() was properly constructed
-        if not expr.arg_kinds[1] in (ARG_POS, ARG_NAMED):
+        if expr.arg_kinds[1] not in (ARG_POS, ARG_NAMED):
             return None
         start_expr = expr.args[1]
     else:
diff --git a/pyproject.toml b/pyproject.toml
index 3d100dff5101a..b46bbd670e601 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -39,3 +39,40 @@ skip_glob = [
     "mypyc/test-data/*",
     "test-data/*",
 ]
+
+[tool.ruff]
+line-length = 99
+target-version = "py37"
+
+select = [
+  "E",       # pycoderstyle (error)
+  "F",       # pyflakes
+  "B",       # flake8-bugbear
+  "RUF100",  # Unused noqa comments
+  "PGH004"  # blanket noqa comments
+]
+
+ignore = [
+  "B006",  # use of mutable defaults in function signatures
+  "B007",  # Loop control variable not used within the loop body.
+  "B011",  # Don't use assert False
+  "B023",  # Function definition does not bind loop variable
+  "E203",  # conflicts with black
+  "E402",  # module level import not at top of file
+  "E501",  # conflicts with black
+  "E731",  # Do not assign a `lambda` expression, use a `def`
+  "E741",  # Ambiguous variable name
+]
+
+extend-exclude = [
+  "@*",
+  # Sphinx configuration is irrelevant
+  "docs/source/conf.py",
+  "mypyc/doc/conf.py",
+  # tests have more relaxed styling requirements
+  # fixtures have their own .pyi-specific configuration
+  "test-data/*",
+  "mypyc/test-data/*",
+  # typeshed has its own .pyi-specific configuration
+  "mypy/typeshed/*",
+]
diff --git a/setup.cfg b/setup.cfg
index 511f794474e7c..04d75ac8d19f2 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -1,46 +1,3 @@
-[flake8]
-max-line-length = 99
-noqa-require-code = True
-# typeshed and unit test fixtures have .pyi-specific flake8 configuration
-exclude =
-  # from .gitignore: directories, and file patterns that intersect with *.py
-  build,
-  bin,
-  lib,
-  include,
-  @*,
-  env,
-  docs/build,
-  out,
-  .venv,
-  .mypy_cache,
-  .git,
-  .cache,
-  # Sphinx configuration is irrelevant
-  docs/source/conf.py,
-  mypyc/doc/conf.py,
-  # tests have more relaxed styling requirements
-  # fixtures have their own .pyi-specific configuration
-  test-data/*,
-  mypyc/test-data/*,
-  # typeshed has its own .pyi-specific configuration
-  mypy/typeshed/*,
-  .tox
-  .eggs
-  .Python
-
-# Things to ignore:
-#   E203: conflicts with black
-#   E501: conflicts with black
-#   W601: has_key() deprecated (false positives)
-#   E402: module level import not at top of file
-#   B006: use of mutable defaults in function signatures
-#   B007: Loop control variable not used within the loop body.
-#   B011: Don't use assert False
-#   B023: Function definition does not bind loop variable
-#   E741: Ambiguous variable name
-extend-ignore = E203,E501,W601,E402,B006,B007,B011,B023,E741
-
 [coverage:run]
 branch = true
 source = mypy
diff --git a/test-data/.flake8 b/test-data/.flake8
deleted file mode 100644
index df2f9caf8c947..0000000000000
--- a/test-data/.flake8
+++ /dev/null
@@ -1,22 +0,0 @@
-# Some PEP8 deviations are considered irrelevant to stub files:
-# (error counts as of 2016-12-19)
-# 17381 E704 multiple statements on one line (def)
-# 11840 E301 expected 1 blank line
-#  7467 E302 expected 2 blank lines
-#  1772 E501 line too long
-#  1487 F401 imported but unused
-#  1248 E701 multiple statements on one line (colon)
-#   427 F811 redefinition
-#   356 E305 expected 2 blank lines
-
-# Nice-to-haves ignored for now
-#   152 E128 continuation line under-indented for visual indent
-#    43 E127 continuation line over-indented for visual indent
-
-[flake8]
-ignore = F401, F811, E127, E128, E301, E302, E305, E501, E701, E704, B303
-# We are checking with Python 3 but many of the stubs are Python 2 stubs.
-# A nice future improvement would be to provide separate .flake8
-# configurations for Python 2 and Python 3 files.
-builtins = StandardError,apply,basestring,buffer,cmp,coerce,execfile,file,intern,long,raw_input,reduce,reload,unichr,unicode,xrange
-exclude = .venv*,@*
diff --git a/test-data/unit/README.md b/test-data/unit/README.md
index 97680c949bef9..f2c727b435435 100644
--- a/test-data/unit/README.md
+++ b/test-data/unit/README.md
@@ -159,7 +159,7 @@ To run mypy on itself:
 
 To run the linter:
 
-    flake8
+    ruff .
 
 You can also run all of the above tests using `runtests.py` (this includes
 type checking mypy and linting):
diff --git a/test-requirements.txt b/test-requirements.txt
index 42c8a08a2b5da..51cd62d4064c0 100644
--- a/test-requirements.txt
+++ b/test-requirements.txt
@@ -3,9 +3,6 @@
 attrs>=18.0
 black==23.3.0  # must match version in .pre-commit-config.yaml
 filelock>=3.3.0
-flake8==6.0.0; python_version >= "3.8"           # must match version in .pre-commit-config.yaml
-flake8-bugbear==23.3.23; python_version >= "3.8" # must match version in .pre-commit-config.yaml
-flake8-noqa==1.3.1; python_version >= "3.8"      # must match version in .pre-commit-config.yaml
 isort[colors]==5.12.0; python_version >= "3.8"   # must match version in .pre-commit-config.yaml
 lxml>=4.9.1; (python_version<'3.11' or sys_platform!='win32') and python_version<'3.12'
 pre-commit
@@ -17,6 +14,7 @@ pytest-xdist>=1.34.0
 pytest-forked>=1.3.0,<2.0.0
 pytest-cov>=2.10.0
 py>=1.5.2
+ruff==0.0.272  # must match version in .pre-commit-config.yaml
 setuptools>=65.5.1
 six
 tomli>=1.1.0

From 88845188c8d1a16e528bb8881a02d374a33af370 Mon Sep 17 00:00:00 2001
From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
Date: Wed, 21 Jun 2023 22:02:21 +0200
Subject: [PATCH 057/129] Bump typing_extensions dependency (#15488)

Co-authored-by: Alex Waygood <Alex.Waygood@Gmail.com>
---
 mypy-requirements.txt | 2 +-
 pyproject.toml        | 2 +-
 setup.py              | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/mypy-requirements.txt b/mypy-requirements.txt
index 9a55446eb05ab..7043765f09f4e 100644
--- a/mypy-requirements.txt
+++ b/mypy-requirements.txt
@@ -1,5 +1,5 @@
 # NOTE: this needs to be kept in sync with the "requires" list in pyproject.toml
-typing_extensions>=3.10
+typing_extensions>=4.1.0
 mypy_extensions>=1.0.0
 typed_ast>=1.4.0,<2; python_version<'3.8'
 tomli>=1.1.0; python_version<'3.11'
diff --git a/pyproject.toml b/pyproject.toml
index b46bbd670e601..fc70d4279681d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -6,7 +6,7 @@ requires = [
     "setuptools >= 40.6.2",
     "wheel >= 0.30.0",
     # the following is from mypy-requirements.txt
-    "typing_extensions>=3.10",
+    "typing_extensions>=4.1.0",
     "mypy_extensions>=1.0.0",
     "typed_ast>=1.4.0,<2; python_version<'3.8'",
     "tomli>=1.1.0; python_version<'3.11'",
diff --git a/setup.py b/setup.py
index 061bb9ddf5b5a..81494a5566e8b 100644
--- a/setup.py
+++ b/setup.py
@@ -222,7 +222,7 @@ def run(self):
     # When changing this, also update mypy-requirements.txt.
     install_requires=[
         "typed_ast >= 1.4.0, < 2; python_version<'3.8'",
-        "typing_extensions>=3.10",
+        "typing_extensions>=4.1.0",
         "mypy_extensions >= 1.0.0",
         "tomli>=1.1.0; python_version<'3.11'",
     ],

From 7d031beb017450ac990c97e288d064290e3be55f Mon Sep 17 00:00:00 2001
From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
Date: Wed, 21 Jun 2023 22:08:37 +0200
Subject: [PATCH 058/129] Add pip as test requirement for PEP 660 editable
 installs (#15482)

---
 test-requirements.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test-requirements.txt b/test-requirements.txt
index 51cd62d4064c0..8aea01f9e996d 100644
--- a/test-requirements.txt
+++ b/test-requirements.txt
@@ -5,6 +5,7 @@ black==23.3.0  # must match version in .pre-commit-config.yaml
 filelock>=3.3.0
 isort[colors]==5.12.0; python_version >= "3.8"   # must match version in .pre-commit-config.yaml
 lxml>=4.9.1; (python_version<'3.11' or sys_platform!='win32') and python_version<'3.12'
+pip>=21.3.1
 pre-commit
 pre-commit-hooks==4.4.0
 psutil>=4.0

From aba35af62078155c9c18f05ae1506fe72dd6121a Mon Sep 17 00:00:00 2001
From: Ilya Priven <ilya.konstantinov@gmail.com>
Date: Thu, 22 Jun 2023 11:07:43 -0400
Subject: [PATCH 059/129] Rename unreachable_lines to skipped_lines (#15483)

In #15164 we've made it so that `# type: ignore`s in lines skipped in
semantic analysis would not be flagged as unused.

In #15164 they were called "unreachable" lines but unreachability during
type-checking can result in the "Statement is unreachable" error, while
these statements are pruned before type-checking, so for clarity we'll
use the term "skipped".
---
 mypy/build.py         |  2 +-
 mypy/errors.py        | 13 +++++++------
 mypy/nodes.py         |  9 +++++----
 mypy/semanal_pass1.py |  8 ++++----
 mypy/server/update.py |  2 +-
 5 files changed, 18 insertions(+), 16 deletions(-)

diff --git a/mypy/build.py b/mypy/build.py
index f388f09098546..08e85dd28624d 100644
--- a/mypy/build.py
+++ b/mypy/build.py
@@ -2238,7 +2238,7 @@ def semantic_analysis_pass1(self) -> None:
         analyzer = SemanticAnalyzerPreAnalysis()
         with self.wrap_context():
             analyzer.visit_file(self.tree, self.xpath, self.id, options)
-        self.manager.errors.set_unreachable_lines(self.xpath, self.tree.unreachable_lines)
+        self.manager.errors.set_skipped_lines(self.xpath, self.tree.skipped_lines)
         # TODO: Do this while constructing the AST?
         self.tree.names = SymbolTable()
         if not self.tree.is_stub:
diff --git a/mypy/errors.py b/mypy/errors.py
index b230b3baa3f6f..0e61f5ecf0cd6 100644
--- a/mypy/errors.py
+++ b/mypy/errors.py
@@ -223,8 +223,9 @@ class Errors:
     # (path -> line -> error-codes)
     ignored_lines: dict[str, dict[int, list[str]]]
 
-    # Lines that are statically unreachable (e.g. due to platform/version check).
-    unreachable_lines: dict[str, set[int]]
+    # Lines that were skipped during semantic analysis e.g. due to ALWAYS_FALSE, MYPY_FALSE,
+    # or platform/version checks. Those lines would not be type-checked.
+    skipped_lines: dict[str, set[int]]
 
     # Lines on which an error was actually ignored.
     used_ignored_lines: dict[str, dict[int, list[str]]]
@@ -281,7 +282,7 @@ def initialize(self) -> None:
         self.import_ctx = []
         self.function_or_member = [None]
         self.ignored_lines = {}
-        self.unreachable_lines = {}
+        self.skipped_lines = {}
         self.used_ignored_lines = defaultdict(lambda: defaultdict(list))
         self.ignored_files = set()
         self.only_once_messages = set()
@@ -330,8 +331,8 @@ def set_file_ignored_lines(
         if ignore_all:
             self.ignored_files.add(file)
 
-    def set_unreachable_lines(self, file: str, unreachable_lines: set[int]) -> None:
-        self.unreachable_lines[file] = unreachable_lines
+    def set_skipped_lines(self, file: str, skipped_lines: set[int]) -> None:
+        self.skipped_lines[file] = skipped_lines
 
     def current_target(self) -> str | None:
         """Retrieves the current target from the associated scope.
@@ -631,7 +632,7 @@ def generate_unused_ignore_errors(self, file: str) -> None:
         ignored_lines = self.ignored_lines[file]
         used_ignored_lines = self.used_ignored_lines[file]
         for line, ignored_codes in ignored_lines.items():
-            if line in self.unreachable_lines[file]:
+            if line in self.skipped_lines[file]:
                 continue
             if codes.UNUSED_IGNORE.code in ignored_codes:
                 continue
diff --git a/mypy/nodes.py b/mypy/nodes.py
index 4e29a434d7fe4..2f4f3f7883852 100644
--- a/mypy/nodes.py
+++ b/mypy/nodes.py
@@ -287,7 +287,7 @@ class MypyFile(SymbolNode):
         "names",
         "imports",
         "ignored_lines",
-        "unreachable_lines",
+        "skipped_lines",
         "is_stub",
         "is_cache_skeleton",
         "is_partial_stub_package",
@@ -314,8 +314,9 @@ class MypyFile(SymbolNode):
     # If the value is empty, ignore all errors; otherwise, the list contains all
     # error codes to ignore.
     ignored_lines: dict[int, list[str]]
-    # Lines that are statically unreachable (e.g. due to platform/version check).
-    unreachable_lines: set[int]
+    # Lines that were skipped during semantic analysis e.g. due to ALWAYS_FALSE, MYPY_FALSE,
+    # or platform/version checks. Those lines would not be type-checked.
+    skipped_lines: set[int]
     # Is this file represented by a stub file (.pyi)?
     is_stub: bool
     # Is this loaded from the cache and thus missing the actual body of the file?
@@ -348,7 +349,7 @@ def __init__(
             self.ignored_lines = ignored_lines
         else:
             self.ignored_lines = {}
-        self.unreachable_lines = set()
+        self.skipped_lines = set()
 
         self.path = ""
         self.is_stub = False
diff --git a/mypy/semanal_pass1.py b/mypy/semanal_pass1.py
index 659f33e65ead6..2df06feacca8f 100644
--- a/mypy/semanal_pass1.py
+++ b/mypy/semanal_pass1.py
@@ -62,7 +62,7 @@ def visit_file(self, file: MypyFile, fnam: str, mod_id: str, options: Options) -
         self.cur_mod_node = file
         self.options = options
         self.is_global_scope = True
-        self.unreachable_lines: set[int] = set()
+        self.skipped_lines: set[int] = set()
 
         for i, defn in enumerate(file.defs):
             defn.accept(self)
@@ -74,10 +74,10 @@ def visit_file(self, file: MypyFile, fnam: str, mod_id: str, options: Options) -
                     next_def, last = file.defs[i + 1], file.defs[-1]
                     if last.end_line is not None:
                         # We are on a Python version recent enough to support end lines.
-                        self.unreachable_lines |= set(range(next_def.line, last.end_line + 1))
+                        self.skipped_lines |= set(range(next_def.line, last.end_line + 1))
                 del file.defs[i + 1 :]
                 break
-        file.unreachable_lines = self.unreachable_lines
+        file.skipped_lines = self.skipped_lines
 
     def visit_func_def(self, node: FuncDef) -> None:
         old_global_scope = self.is_global_scope
@@ -127,7 +127,7 @@ def visit_block(self, b: Block) -> None:
         if b.is_unreachable:
             if b.end_line is not None:
                 # We are on a Python version recent enough to support end lines.
-                self.unreachable_lines |= set(range(b.line, b.end_line + 1))
+                self.skipped_lines |= set(range(b.line, b.end_line + 1))
             return
         super().visit_block(b)
 
diff --git a/mypy/server/update.py b/mypy/server/update.py
index 7b439eb0ab9fa..dafed6642d1e6 100644
--- a/mypy/server/update.py
+++ b/mypy/server/update.py
@@ -986,7 +986,7 @@ def key(node: FineGrainedDeferredNode) -> int:
     manager.errors.set_file_ignored_lines(
         file_node.path, file_node.ignored_lines, options.ignore_errors or state.ignore_all
     )
-    manager.errors.set_unreachable_lines(file_node.path, file_node.unreachable_lines)
+    manager.errors.set_skipped_lines(file_node.path, file_node.skipped_lines)
 
     targets = set()
     for node in nodes:

From a5e316eafdd98ad73847e41436a3158e976ed769 Mon Sep 17 00:00:00 2001
From: Nikita Sobolev <mail@sobolevn.me>
Date: Thu, 22 Jun 2023 19:47:23 +0300
Subject: [PATCH 060/129] Do not import `TypedDict` from `mypy-extensions`, use
 `typing-extensions` (#15494)

All recent versions (declared in `setup.py`) have `TypedDict` there. So,
no need to use `mypy-extensions` here.

(crossref: found while working on
https://github.com/typeddjango/django-stubs/pull/1566)
---
 mypy/build.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/mypy/build.py b/mypy/build.py
index 08e85dd28624d..5a6f8c00896e3 100644
--- a/mypy/build.py
+++ b/mypy/build.py
@@ -38,9 +38,7 @@
     Sequence,
     TextIO,
 )
-from typing_extensions import Final, TypeAlias as _TypeAlias
-
-from mypy_extensions import TypedDict
+from typing_extensions import Final, TypeAlias as _TypeAlias, TypedDict
 
 import mypy.semanal_main
 from mypy.checker import TypeChecker
@@ -343,7 +341,9 @@ class CacheMeta(NamedTuple):
 
 
 # Metadata for the fine-grained dependencies file associated with a module.
-FgDepMeta = TypedDict("FgDepMeta", {"path": str, "mtime": int})
+class FgDepMeta(TypedDict):
+    path: str
+    mtime: int
 
 
 def cache_meta_from_dict(meta: dict[str, Any], data_json: str) -> CacheMeta:

From 2e304ca36df9975299769b3b40ec9d73ad4f68b4 Mon Sep 17 00:00:00 2001
From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
Date: Fri, 23 Jun 2023 00:01:15 +0200
Subject: [PATCH 061/129] Fix PEP 561 editable install test case (#15493)

---
 mypy/test/testpep561.py | 25 +++++++++++++++++++++++++
 test-requirements.txt   |  1 -
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/mypy/test/testpep561.py b/mypy/test/testpep561.py
index b8a11d7fc8afd..da5025faef038 100644
--- a/mypy/test/testpep561.py
+++ b/mypy/test/testpep561.py
@@ -46,6 +46,28 @@ def virtualenv(python_executable: str = sys.executable) -> Iterator[tuple[str, s
             yield venv_dir, os.path.abspath(os.path.join(venv_dir, "bin", "python"))
 
 
+def upgrade_pip(python_executable: str) -> None:
+    """Install pip>=21.3.1. Required for editable installs with PEP 660."""
+    if (
+        sys.version_info >= (3, 11)
+        or (3, 10, 3) <= sys.version_info < (3, 11)
+        or (3, 9, 11) <= sys.version_info < (3, 10)
+        or (3, 8, 13) <= sys.version_info < (3, 9)
+    ):
+        # Skip for more recent Python releases which come with pip>=21.3.1
+        # out of the box - for performance reasons.
+        return
+
+    install_cmd = [python_executable, "-m", "pip", "install", "pip>=21.3.1"]
+    try:
+        with filelock.FileLock(pip_lock, timeout=pip_timeout):
+            proc = subprocess.run(install_cmd, capture_output=True, env=os.environ)
+    except filelock.Timeout as err:
+        raise Exception(f"Failed to acquire {pip_lock}") from err
+    if proc.returncode != 0:
+        raise Exception(proc.stdout.decode("utf-8") + proc.stderr.decode("utf-8"))
+
+
 def install_package(
     pkg: str, python_executable: str = sys.executable, editable: bool = False
 ) -> None:
@@ -93,6 +115,9 @@ def test_pep561(testcase: DataDrivenTestCase) -> None:
     assert pkgs, "No packages to install for PEP 561 test?"
     with virtualenv(python) as venv:
         venv_dir, python_executable = venv
+        if editable:
+            # Editable installs with PEP 660 require pip>=21.3
+            upgrade_pip(python_executable)
         for pkg in pkgs:
             install_package(pkg, python_executable, editable)
 
diff --git a/test-requirements.txt b/test-requirements.txt
index 8aea01f9e996d..51cd62d4064c0 100644
--- a/test-requirements.txt
+++ b/test-requirements.txt
@@ -5,7 +5,6 @@ black==23.3.0  # must match version in .pre-commit-config.yaml
 filelock>=3.3.0
 isort[colors]==5.12.0; python_version >= "3.8"   # must match version in .pre-commit-config.yaml
 lxml>=4.9.1; (python_version<'3.11' or sys_platform!='win32') and python_version<'3.12'
-pip>=21.3.1
 pre-commit
 pre-commit-hooks==4.4.0
 psutil>=4.0

From c918d40b1500d141d14764ef967ca56ce633efb2 Mon Sep 17 00:00:00 2001
From: Nikita Sobolev <mail@sobolevn.me>
Date: Fri, 23 Jun 2023 06:59:31 +0300
Subject: [PATCH 062/129] Use `()` for `get_function_sig_hook` docs (#15499)

---
 docs/source/extending_mypy.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/source/extending_mypy.rst b/docs/source/extending_mypy.rst
index daf8636163344..506f548db687e 100644
--- a/docs/source/extending_mypy.rst
+++ b/docs/source/extending_mypy.rst
@@ -159,7 +159,7 @@ This hook will be also called for instantiation of classes.
 This is a good choice if the return type is too complex
 to be expressed by regular python typing.
 
-**get_function_signature_hook** is used to adjust the signature of a function.
+**get_function_signature_hook()** is used to adjust the signature of a function.
 
 **get_method_hook()** is the same as ``get_function_hook()`` but for methods
 instead of module level functions.

From a47279b8626e3885580df1a33c179fc5b7e273ce Mon Sep 17 00:00:00 2001
From: Alex Waygood <Alex.Waygood@Gmail.com>
Date: Fri, 23 Jun 2023 12:41:03 +0100
Subject: [PATCH 063/129] Remove `py` and `pytest-forked` test dependencies
 (#15501)

We don't use either of these in our own code at all. Neither of them
should be needed in 2023.

py used to be a dependency of pytest but no longer is. It was added to
test-requirements.txt 6 years ago in order to pin a specific version to
fix an issue where some tests were failing:
https://github.com/python/mypy/commit/5168c2580ff81ba114776936bdeaf5d81812c34a
and
https://github.com/python/mypy/commit/ad6dd4ed6923a5eb6227fc9bfcb8e30a5e0fde53.

pytest-forked used to be a dependency of pytest-xdist, but no longer is.
It was added to test-requirements.txt` 4 years ago in order to pin a
specific version to fix builds on macOS:
https://github.com/python/mypy/commit/e006b94e097184451e6baf9b9c55e56176728ab8.
---
 test-requirements.txt | 2 --
 1 file changed, 2 deletions(-)

diff --git a/test-requirements.txt b/test-requirements.txt
index 51cd62d4064c0..7c4b3b869de5e 100644
--- a/test-requirements.txt
+++ b/test-requirements.txt
@@ -11,9 +11,7 @@ psutil>=4.0
 # pytest 6.2.3 does not support Python 3.10
 pytest>=6.2.4
 pytest-xdist>=1.34.0
-pytest-forked>=1.3.0,<2.0.0
 pytest-cov>=2.10.0
-py>=1.5.2
 ruff==0.0.272  # must match version in .pre-commit-config.yaml
 setuptools>=65.5.1
 six

From 2f56b3f8ce1aed0cee7e163af2a0d442a3939023 Mon Sep 17 00:00:00 2001
From: Alex Waygood <Alex.Waygood@Gmail.com>
Date: Fri, 23 Jun 2023 13:53:14 +0100
Subject: [PATCH 064/129] Unbreak CI (#15505)

pytest 7.4.0 was just released, and our CI on `master` is very red as a
result. Looks like we're using a private API that we shouldn't be:
https://github.com/python/mypy/pull/15501#issuecomment-1604177495. For
now let's just pin to pytest <7.4.0.

https://pypi.org/project/pytest/7.4.0/
---
 test-requirements.txt | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test-requirements.txt b/test-requirements.txt
index 7c4b3b869de5e..f7d37058e544d 100644
--- a/test-requirements.txt
+++ b/test-requirements.txt
@@ -9,7 +9,8 @@ pre-commit
 pre-commit-hooks==4.4.0
 psutil>=4.0
 # pytest 6.2.3 does not support Python 3.10
-pytest>=6.2.4
+# TODO: fix use of removed private APIs so we can use the latest pytest
+pytest>=6.2.4,<7.4.0
 pytest-xdist>=1.34.0
 pytest-cov>=2.10.0
 ruff==0.0.272  # must match version in .pre-commit-config.yaml

From 2d8ad8ef240df262be80d9359e9f5892ea1f9ad3 Mon Sep 17 00:00:00 2001
From: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
Date: Fri, 23 Jun 2023 06:05:05 -0700
Subject: [PATCH 065/129] Fix async iterator body stripping (#15491)

Fixes #15489
---
 mypy/fastparse.py                     | 58 +++++++++++++++------------
 test-data/unit/check-async-await.test | 13 ++++--
 2 files changed, 43 insertions(+), 28 deletions(-)

diff --git a/mypy/fastparse.py b/mypy/fastparse.py
index 902bde1104214..fe59ff48bdfcf 100644
--- a/mypy/fastparse.py
+++ b/mypy/fastparse.py
@@ -521,7 +521,14 @@ def translate_stmt_list(
             return [block]
 
         stack = self.class_and_function_stack
-        if self.strip_function_bodies and len(stack) == 1 and stack[0] == "F":
+        # Fast case for stripping function bodies
+        if (
+            can_strip
+            and self.strip_function_bodies
+            and len(stack) == 1
+            and stack[0] == "F"
+            and not is_coroutine
+        ):
             return []
 
         res: list[Statement] = []
@@ -529,32 +536,33 @@ def translate_stmt_list(
             node = self.visit(stmt)
             res.append(node)
 
-        if (
-            self.strip_function_bodies
-            and can_strip
-            and stack[-2:] == ["C", "F"]
-            and not is_possible_trivial_body(res)
-        ):
-            # We only strip method bodies if they don't assign to an attribute, as
-            # this may define an attribute which has an externally visible effect.
-            visitor = FindAttributeAssign()
-            for s in res:
-                s.accept(visitor)
-                if visitor.found:
-                    break
-            else:
-                if is_coroutine:
-                    # Yields inside an async function affect the return type and should not
-                    # be stripped.
-                    yield_visitor = FindYield()
+        # Slow case for stripping function bodies
+        if can_strip and self.strip_function_bodies:
+            if stack[-2:] == ["C", "F"]:
+                if is_possible_trivial_body(res):
+                    can_strip = False
+                else:
+                    # We only strip method bodies if they don't assign to an attribute, as
+                    # this may define an attribute which has an externally visible effect.
+                    visitor = FindAttributeAssign()
                     for s in res:
-                        s.accept(yield_visitor)
-                        if yield_visitor.found:
+                        s.accept(visitor)
+                        if visitor.found:
+                            can_strip = False
                             break
-                    else:
-                        return []
-                else:
-                    return []
+
+            if can_strip and stack[-1] == "F" and is_coroutine:
+                # Yields inside an async function affect the return type and should not
+                # be stripped.
+                yield_visitor = FindYield()
+                for s in res:
+                    s.accept(yield_visitor)
+                    if yield_visitor.found:
+                        can_strip = False
+                        break
+
+            if can_strip:
+                return []
         return res
 
     def translate_type_comment(
diff --git a/test-data/unit/check-async-await.test b/test-data/unit/check-async-await.test
index 83a66ef4a8159..d0df2c9e01042 100644
--- a/test-data/unit/check-async-await.test
+++ b/test-data/unit/check-async-await.test
@@ -945,17 +945,21 @@ async def bar(x: Union[A, B]) -> None:
 [typing fixtures/typing-async.pyi]
 
 [case testAsyncIteratorWithIgnoredErrors]
-from m import L
+import m
 
-async def func(l: L) -> None:
+async def func(l: m.L) -> None:
     reveal_type(l.get_iterator)  # N: Revealed type is "def () -> typing.AsyncIterator[builtins.str]"
     reveal_type(l.get_iterator2)  # N: Revealed type is "def () -> typing.AsyncIterator[builtins.str]"
     async for i in l.get_iterator():
         reveal_type(i)  # N: Revealed type is "builtins.str"
 
+    reveal_type(m.get_generator)  # N: Revealed type is "def () -> typing.AsyncGenerator[builtins.int, None]"
+    async for i2 in m.get_generator():
+        reveal_type(i2)  # N: Revealed type is "builtins.int"
+
 [file m.py]
 # mypy: ignore-errors=True
-from typing import AsyncIterator
+from typing import AsyncIterator, AsyncGenerator
 
 class L:
     async def some_func(self, i: int) -> str:
@@ -968,6 +972,9 @@ class L:
         if self:
             a = (yield 'x')
 
+async def get_generator() -> AsyncGenerator[int, None]:
+    yield 1
+
 [builtins fixtures/async_await.pyi]
 [typing fixtures/typing-async.pyi]
 

From c099b20df02778455aaa3b5f59bb4deca096b8b0 Mon Sep 17 00:00:00 2001
From: Nikita Sobolev <mail@sobolevn.me>
Date: Fri, 23 Jun 2023 17:38:37 +0300
Subject: [PATCH 066/129] Fix error location for class patterns (#15506)

Now it uses the same pattern for `.fail` as similar places:
-
https://github.com/python/mypy/blob/2d8ad8ef240df262be80d9359e9f5892ea1f9ad3/mypy/checkpattern.py#L459
-
https://github.com/python/mypy/blob/2d8ad8ef240df262be80d9359e9f5892ea1f9ad3/mypy/checkpattern.py#L493
- etc

Test proves that this problem is now fixed.
Closes #15496
---
 mypy/checkpattern.py                |  2 +-
 test-data/unit/check-python310.test | 20 ++++++++++++++++++++
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/mypy/checkpattern.py b/mypy/checkpattern.py
index e132a23ff55f3..50d7b8a9826f0 100644
--- a/mypy/checkpattern.py
+++ b/mypy/checkpattern.py
@@ -468,7 +468,7 @@ def visit_class_pattern(self, o: ClassPattern) -> PatternType:
                 name = type_info.type.str_with_options(self.options)
             else:
                 name = type_info.name
-            self.msg.fail(message_registry.CLASS_PATTERN_TYPE_REQUIRED.format(name), o.class_ref)
+            self.msg.fail(message_registry.CLASS_PATTERN_TYPE_REQUIRED.format(name), o)
             return self.early_non_match()
 
         new_type, rest_type = self.chk.conditional_types_with_intersection(
diff --git a/test-data/unit/check-python310.test b/test-data/unit/check-python310.test
index feedd02d82eb5..6416fa02bbce7 100644
--- a/test-data/unit/check-python310.test
+++ b/test-data/unit/check-python310.test
@@ -1958,3 +1958,23 @@ def redefinition_bad(a: int):
             ...
 
 [builtins fixtures/primitives.pyi]
+
+[case testPatternMatchingClassPatternLocation]
+# See https://github.com/python/mypy/issues/15496
+from some_missing_lib import DataFrame, Series  # type: ignore[import]
+from typing import TypeVar
+
+T = TypeVar("T", Series, DataFrame)
+
+def f(x: T) -> None:
+    match x:
+        case Series() | DataFrame():  # type: ignore[misc]
+            pass
+
+def f2(x: T) -> None:
+    match x:
+        case Series():  # type: ignore[misc]
+            pass
+        case DataFrame():  # type: ignore[misc]
+            pass
+[builtins fixtures/primitives.pyi]

From c23936931688f69b9b9782e7d79c123698458e66 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Fri, 23 Jun 2023 18:20:39 +0100
Subject: [PATCH 067/129] [mypyc] Support the i16 native integer type (#15464)

The `i16` type behaves the same as `i64` and `i32`, but is obviously
smaller. The PR is big, but it's mostly because of test cases, which are
adapted from `i32` test cases.

Also fix error handling in unboxing of native int and float types (i.e.
all types with overlapping error values).
---
 mypy/types.py                               |   6 +-
 mypyc/codegen/emit.py                       |  35 +-
 mypyc/doc/float_operations.rst              |   6 +-
 mypyc/doc/int_operations.rst                |  25 +-
 mypyc/doc/using_type_annotations.rst        |  16 +-
 mypyc/ir/rtypes.py                          |  20 +-
 mypyc/irbuild/ll_builder.py                 |  14 +-
 mypyc/irbuild/mapper.py                     |   3 +
 mypyc/irbuild/specialize.py                 |  27 +-
 mypyc/lib-rt/CPy.h                          |   4 +
 mypyc/lib-rt/int_ops.c                      |  69 +++
 mypyc/primitives/int_ops.py                 |  29 +-
 mypyc/test-data/irbuild-i16.test            | 504 ++++++++++++++++++++
 mypyc/test-data/irbuild-i32.test            |  11 +-
 mypyc/test-data/irbuild-i64.test            |  11 +-
 mypyc/test-data/run-i16.test                | 338 +++++++++++++
 mypyc/test-data/run-i32.test                |   8 +-
 mypyc/test-data/run-i64.test                |  19 +-
 mypyc/test/test_irbuild.py                  |   1 +
 mypyc/test/test_run.py                      |   1 +
 mypyc/test/test_typeops.py                  |  22 +-
 test-data/unit/lib-stub/mypy_extensions.pyi |  32 +-
 22 files changed, 1160 insertions(+), 41 deletions(-)
 create mode 100644 mypyc/test-data/irbuild-i16.test
 create mode 100644 mypyc/test-data/run-i16.test

diff --git a/mypy/types.py b/mypy/types.py
index 25bfdd8b03c47..33673b58f7758 100644
--- a/mypy/types.py
+++ b/mypy/types.py
@@ -150,7 +150,11 @@
 )
 
 # Mypyc fixed-width native int types (compatible with builtins.int)
-MYPYC_NATIVE_INT_NAMES: Final = ("mypy_extensions.i64", "mypy_extensions.i32")
+MYPYC_NATIVE_INT_NAMES: Final = (
+    "mypy_extensions.i64",
+    "mypy_extensions.i32",
+    "mypy_extensions.i16",
+)
 
 DATACLASS_TRANSFORM_NAMES: Final = (
     "typing.dataclass_transform",
diff --git a/mypyc/codegen/emit.py b/mypyc/codegen/emit.py
index 8114e05172199..8f0e0bc65edc4 100644
--- a/mypyc/codegen/emit.py
+++ b/mypyc/codegen/emit.py
@@ -35,6 +35,7 @@
     is_dict_rprimitive,
     is_fixed_width_rtype,
     is_float_rprimitive,
+    is_int16_rprimitive,
     is_int32_rprimitive,
     is_int64_rprimitive,
     is_int_rprimitive,
@@ -900,28 +901,35 @@ def emit_unbox(
             self.emit_line(f"    {dest} = 1;")
         elif is_int64_rprimitive(typ):
             # Whether we are borrowing or not makes no difference.
+            assert not optional  # Not supported for overlapping error values
             if declare_dest:
                 self.emit_line(f"int64_t {dest};")
             self.emit_line(f"{dest} = CPyLong_AsInt64({src});")
-            # TODO: Handle 'optional'
-            # TODO: Handle 'failure'
+            if not isinstance(error, AssignHandler):
+                self.emit_unbox_failure_with_overlapping_error_value(dest, typ, failure)
         elif is_int32_rprimitive(typ):
             # Whether we are borrowing or not makes no difference.
+            assert not optional  # Not supported for overlapping error values
             if declare_dest:
                 self.emit_line(f"int32_t {dest};")
             self.emit_line(f"{dest} = CPyLong_AsInt32({src});")
-            # TODO: Handle 'optional'
-            # TODO: Handle 'failure'
+            if not isinstance(error, AssignHandler):
+                self.emit_unbox_failure_with_overlapping_error_value(dest, typ, failure)
+        elif is_int16_rprimitive(typ):
+            # Whether we are borrowing or not makes no difference.
+            assert not optional  # Not supported for overlapping error values
+            if declare_dest:
+                self.emit_line(f"int16_t {dest};")
+            self.emit_line(f"{dest} = CPyLong_AsInt16({src});")
+            if not isinstance(error, AssignHandler):
+                self.emit_unbox_failure_with_overlapping_error_value(dest, typ, failure)
         elif is_float_rprimitive(typ):
+            assert not optional  # Not supported for overlapping error values
             if declare_dest:
                 self.emit_line("double {};".format(dest))
             # TODO: Don't use __float__ and __index__
             self.emit_line(f"{dest} = PyFloat_AsDouble({src});")
-            self.emit_lines(
-                f"if ({dest} == -1.0 && PyErr_Occurred()) {{", f"{dest} = -113.0;", "}"
-            )
-            # TODO: Handle 'optional'
-            # TODO: Handle 'failure'
+            self.emit_lines(f"if ({dest} == -1.0 && PyErr_Occurred()) {{", failure, "}")
         elif isinstance(typ, RTuple):
             self.declare_tuple_struct(typ)
             if declare_dest:
@@ -1006,7 +1014,7 @@ def emit_box(
             self.emit_lines(f"{declaration}{dest} = Py_None;")
             if not can_borrow:
                 self.emit_inc_ref(dest, object_rprimitive)
-        elif is_int32_rprimitive(typ):
+        elif is_int32_rprimitive(typ) or is_int16_rprimitive(typ):
             self.emit_line(f"{declaration}{dest} = PyLong_FromLong({src});")
         elif is_int64_rprimitive(typ):
             self.emit_line(f"{declaration}{dest} = PyLong_FromLongLong({src});")
@@ -1137,6 +1145,13 @@ def _emit_traceback(
         if DEBUG_ERRORS:
             self.emit_line('assert(PyErr_Occurred() != NULL && "failure w/o err!");')
 
+    def emit_unbox_failure_with_overlapping_error_value(
+        self, dest: str, typ: RType, failure: str
+    ) -> None:
+        self.emit_line(f"if ({dest} == {self.c_error_value(typ)} && PyErr_Occurred()) {{")
+        self.emit_line(failure)
+        self.emit_line("}")
+
 
 def c_array_initializer(components: list[str], *, indented: bool = False) -> str:
     """Construct an initializer for a C array variable.
diff --git a/mypyc/doc/float_operations.rst b/mypyc/doc/float_operations.rst
index 915c184ae8e7d..1705b76724093 100644
--- a/mypyc/doc/float_operations.rst
+++ b/mypyc/doc/float_operations.rst
@@ -14,6 +14,7 @@ Construction
 * ``float(x: int)``
 * ``float(x: i64)``
 * ``float(x: i32)``
+* ``float(x: i16)``
 * ``float(x: str)``
 * ``float(x: float)`` (no-op)
 
@@ -28,8 +29,9 @@ Functions
 ---------
 
 * ``int(f)``
-* ``i32(f)`` (convert to ``i32``)
-* ``i64(f)`` (convert to ``i64``)
+* ``i64(f)`` (convert to 64-bit signed integer)
+* ``i32(f)`` (convert to 32-bit signed integer)
+* ``i16(f)`` (convert to 16-bit signed integer)
 * ``abs(f)``
 * ``math.sin(f)``
 * ``math.cos(f)``
diff --git a/mypyc/doc/int_operations.rst b/mypyc/doc/int_operations.rst
index 058fdbd511dd9..88a4a9d778a1c 100644
--- a/mypyc/doc/int_operations.rst
+++ b/mypyc/doc/int_operations.rst
@@ -8,14 +8,16 @@ Mypyc supports these integer types:
 * ``int`` (arbitrary-precision integer)
 * ``i64`` (64-bit signed integer)
 * ``i32`` (32-bit signed integer)
+* ``i16`` (16-bit signed integer)
 
-``i64`` and ``i32`` are *native integer types* and must be imported
+``i64``, ``i32`` and ``i16`` are *native integer types* and must be imported
 from the ``mypy_extensions`` module. ``int`` corresponds to the Python
 ``int`` type, but uses a more efficient runtime representation (tagged
-pointer). Native integer types are value types. All integer types have
-optimized primitive operations, but the native integer types are more
-efficient than ``int``, since they don't require range or bounds
-checks.
+pointer). Native integer types are value types.
+
+All integer types have optimized primitive operations, but the native
+integer types are more efficient than ``int``, since they don't
+require range or bounds checks.
 
 Operations on integers that are listed here have fast, optimized
 implementations. Other integer operations use generic implementations
@@ -31,6 +33,7 @@ Construction
 * ``int(x: float)``
 * ``int(x: i64)``
 * ``int(x: i32)``
+* ``int(x: i16)``
 * ``int(x: str)``
 * ``int(x: str, base: int)``
 * ``int(x: int)`` (no-op)
@@ -40,6 +43,7 @@ Construction
 * ``i64(x: int)``
 * ``i64(x: float)``
 * ``i64(x: i32)``
+* ``i64(x: i16)``
 * ``i64(x: str)``
 * ``i64(x: str, base: int)``
 * ``i64(x: i64)`` (no-op)
@@ -49,10 +53,21 @@ Construction
 * ``i32(x: int)``
 * ``i32(x: float)``
 * ``i32(x: i64)`` (truncate)
+* ``i32(x: i16)``
 * ``i32(x: str)``
 * ``i32(x: str, base: int)``
 * ``i32(x: i32)`` (no-op)
 
+``i16`` type:
+
+* ``i16(x: int)``
+* ``i16(x: float)``
+* ``i16(x: i64)`` (truncate)
+* ``i16(x: i32)`` (truncate)
+* ``i16(x: str)``
+* ``i16(x: str, base: int)``
+* ``i16(x: i16)`` (no-op)
+
 Conversions from ``int`` to a native integer type raise
 ``OverflowError`` if the value is too large or small. Conversions from
 a wider native integer type to a narrower one truncate the value and never
diff --git a/mypyc/doc/using_type_annotations.rst b/mypyc/doc/using_type_annotations.rst
index 6c92777867511..f095a67172717 100644
--- a/mypyc/doc/using_type_annotations.rst
+++ b/mypyc/doc/using_type_annotations.rst
@@ -32,6 +32,7 @@ implementations:
 * ``int`` (:ref:`native operations <int-ops>`)
 * ``i64`` (:ref:`documentation <native-ints>`, :ref:`native operations <int-ops>`)
 * ``i32`` (:ref:`documentation <native-ints>`, :ref:`native operations <int-ops>`)
+* ``i16`` (:ref:`documentation <native-ints>`, :ref:`native operations <int-ops>`)
 * ``float`` (:ref:`native operations <float-ops>`)
 * ``bool`` (:ref:`native operations <bool-ops>`)
 * ``str`` (:ref:`native operations <str-ops>`)
@@ -342,13 +343,14 @@ Examples::
 Native integer types
 --------------------
 
-You can use the native integer types ``i64`` (64-bit signed integer)
-and ``i32`` (32-bit signed integer) if you know that integer values
-will always fit within fixed bounds. These types are faster than the
-arbitrary-precision ``int`` type, since they don't require overflow
-checks on operations. ``i32`` may also use less memory than ``int``
-values. The types are imported from the ``mypy_extensions`` module
-(installed via ``pip install mypy_extensions``).
+You can use the native integer types ``i64`` (64-bit signed integer),
+``i32`` (32-bit signed integer), and ``i16`` (16-bit signed integer)
+if you know that integer values will always fit within fixed
+bounds. These types are faster than the arbitrary-precision ``int``
+type, since they don't require overflow checks on operations. ``i32``
+and ``i16`` may also use less memory than ``int`` values. The types
+are imported from the ``mypy_extensions`` module (installed via ``pip
+install mypy_extensions``).
 
 Example::
 
diff --git a/mypyc/ir/rtypes.py b/mypyc/ir/rtypes.py
index 7ff82ac9b2973..61f83c9c041eb 100644
--- a/mypyc/ir/rtypes.py
+++ b/mypyc/ir/rtypes.py
@@ -206,7 +206,7 @@ def __init__(
         self.error_overlap = error_overlap
         if ctype == "CPyTagged":
             self.c_undefined = "CPY_INT_TAG"
-        elif ctype in ("int32_t", "int64_t"):
+        elif ctype in ("int16_t", "int32_t", "int64_t"):
             # This is basically an arbitrary value that is pretty
             # unlikely to overlap with a real value.
             self.c_undefined = "-113"
@@ -290,6 +290,16 @@ def __hash__(self) -> int:
 
 # Low level integer types (correspond to C integer types)
 
+int16_rprimitive: Final = RPrimitive(
+    "int16",
+    is_unboxed=True,
+    is_refcounted=False,
+    is_native_int=True,
+    is_signed=True,
+    ctype="int16_t",
+    size=2,
+    error_overlap=True,
+)
 int32_rprimitive: Final = RPrimitive(
     "int32",
     is_unboxed=True,
@@ -432,6 +442,10 @@ def is_short_int_rprimitive(rtype: RType) -> bool:
     return rtype is short_int_rprimitive
 
 
+def is_int16_rprimitive(rtype: RType) -> bool:
+    return rtype is int16_rprimitive
+
+
 def is_int32_rprimitive(rtype: RType) -> bool:
     return rtype is int32_rprimitive or (
         rtype is c_pyssize_t_rprimitive and rtype._ctype == "int32_t"
@@ -445,7 +459,7 @@ def is_int64_rprimitive(rtype: RType) -> bool:
 
 
 def is_fixed_width_rtype(rtype: RType) -> bool:
-    return is_int32_rprimitive(rtype) or is_int64_rprimitive(rtype)
+    return is_int64_rprimitive(rtype) or is_int32_rprimitive(rtype) or is_int16_rprimitive(rtype)
 
 
 def is_uint32_rprimitive(rtype: RType) -> bool:
@@ -536,6 +550,8 @@ def visit_rprimitive(self, t: RPrimitive) -> str:
             return "8"  # "8 byte integer"
         elif t._ctype == "int32_t":
             return "4"  # "4 byte integer"
+        elif t._ctype == "int16_t":
+            return "2"  # "2 byte integer"
         elif t._ctype == "double":
             return "F"
         assert not t.is_unboxed, f"{t} unexpected unboxed type"
diff --git a/mypyc/irbuild/ll_builder.py b/mypyc/irbuild/ll_builder.py
index aa152d32a144d..a37bcc0dbb86a 100644
--- a/mypyc/irbuild/ll_builder.py
+++ b/mypyc/irbuild/ll_builder.py
@@ -104,6 +104,7 @@
     is_dict_rprimitive,
     is_fixed_width_rtype,
     is_float_rprimitive,
+    is_int16_rprimitive,
     is_int32_rprimitive,
     is_int64_rprimitive,
     is_int_rprimitive,
@@ -146,6 +147,9 @@
     py_vectorcall_op,
 )
 from mypyc.primitives.int_ops import (
+    int16_divide_op,
+    int16_mod_op,
+    int16_overflow,
     int32_divide_op,
     int32_mod_op,
     int32_overflow,
@@ -456,6 +460,10 @@ def coerce_int_to_fixed_width(self, src: Value, target_type: RType, line: int) -
             # Slow path just always generates an OverflowError
             self.call_c(int32_overflow, [], line)
             self.add(Unreachable())
+        elif is_int16_rprimitive(target_type):
+            # Slow path just always generates an OverflowError
+            self.call_c(int16_overflow, [], line)
+            self.add(Unreachable())
         else:
             assert False, target_type
 
@@ -469,7 +477,7 @@ def coerce_short_int_to_fixed_width(self, src: Value, target_type: RType, line:
         assert False, (src.type, target_type)
 
     def coerce_fixed_width_to_int(self, src: Value, line: int) -> Value:
-        if is_int32_rprimitive(src.type) and PLATFORM_SIZE == 8:
+        if (is_int32_rprimitive(src.type) and PLATFORM_SIZE == 8) or is_int16_rprimitive(src.type):
             # Simple case -- just sign extend and shift.
             extended = self.add(Extend(src, c_pyssize_t_rprimitive, signed=True))
             return self.int_op(
@@ -2038,6 +2046,8 @@ def fixed_width_int_op(self, type: RType, lhs: Value, rhs: Value, op: int, line:
                 prim = int64_divide_op
             elif is_int32_rprimitive(type):
                 prim = int32_divide_op
+            elif is_int16_rprimitive(type):
+                prim = int16_divide_op
             else:
                 assert False, type
             return self.call_c(prim, [lhs, rhs], line)
@@ -2050,6 +2060,8 @@ def fixed_width_int_op(self, type: RType, lhs: Value, rhs: Value, op: int, line:
                 prim = int64_mod_op
             elif is_int32_rprimitive(type):
                 prim = int32_mod_op
+            elif is_int16_rprimitive(type):
+                prim = int16_mod_op
             else:
                 assert False, type
             return self.call_c(prim, [lhs, rhs], line)
diff --git a/mypyc/irbuild/mapper.py b/mypyc/irbuild/mapper.py
index dddb35230fd5c..a4712f4af524c 100644
--- a/mypyc/irbuild/mapper.py
+++ b/mypyc/irbuild/mapper.py
@@ -32,6 +32,7 @@
     bytes_rprimitive,
     dict_rprimitive,
     float_rprimitive,
+    int16_rprimitive,
     int32_rprimitive,
     int64_rprimitive,
     int_rprimitive,
@@ -102,6 +103,8 @@ def type_to_rtype(self, typ: Type | None) -> RType:
                 return int64_rprimitive
             elif typ.type.fullname == "mypy_extensions.i32":
                 return int32_rprimitive
+            elif typ.type.fullname == "mypy_extensions.i16":
+                return int16_rprimitive
             else:
                 return object_rprimitive
         elif isinstance(typ, TupleType):
diff --git a/mypyc/irbuild/specialize.py b/mypyc/irbuild/specialize.py
index 14a6f8e92df2d..06af4d6d74269 100644
--- a/mypyc/irbuild/specialize.py
+++ b/mypyc/irbuild/specialize.py
@@ -49,6 +49,7 @@
     bool_rprimitive,
     c_int_rprimitive,
     dict_rprimitive,
+    int16_rprimitive,
     int32_rprimitive,
     int64_rprimitive,
     int_rprimitive,
@@ -56,6 +57,7 @@
     is_dict_rprimitive,
     is_fixed_width_rtype,
     is_float_rprimitive,
+    is_int16_rprimitive,
     is_int32_rprimitive,
     is_int64_rprimitive,
     is_int_rprimitive,
@@ -163,6 +165,7 @@ def translate_globals(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Va
 @specialize_function("builtins.complex")
 @specialize_function("mypy_extensions.i64")
 @specialize_function("mypy_extensions.i32")
+@specialize_function("mypy_extensions.i16")
 def translate_builtins_with_unary_dunder(
     builder: IRBuilder, expr: CallExpr, callee: RefExpr
 ) -> Value | None:
@@ -171,7 +174,7 @@ def translate_builtins_with_unary_dunder(
         arg = expr.args[0]
         arg_typ = builder.node_type(arg)
         shortname = callee.fullname.split(".")[1]
-        if shortname in ("i64", "i32"):
+        if shortname in ("i64", "i32", "i16"):
             method = "__int__"
         else:
             method = f"__{shortname}__"
@@ -680,7 +683,7 @@ def translate_i64(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value
     arg_type = builder.node_type(arg)
     if is_int64_rprimitive(arg_type):
         return builder.accept(arg)
-    elif is_int32_rprimitive(arg_type):
+    elif is_int32_rprimitive(arg_type) or is_int16_rprimitive(arg_type):
         val = builder.accept(arg)
         return builder.add(Extend(val, int64_rprimitive, signed=True, line=expr.line))
     elif is_int_rprimitive(arg_type) or is_bool_rprimitive(arg_type):
@@ -700,12 +703,32 @@ def translate_i32(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value
     elif is_int64_rprimitive(arg_type):
         val = builder.accept(arg)
         return builder.add(Truncate(val, int32_rprimitive, line=expr.line))
+    elif is_int16_rprimitive(arg_type):
+        val = builder.accept(arg)
+        return builder.add(Extend(val, int32_rprimitive, signed=True, line=expr.line))
     elif is_int_rprimitive(arg_type) or is_bool_rprimitive(arg_type):
         val = builder.accept(arg)
         return builder.coerce(val, int32_rprimitive, expr.line)
     return None
 
 
+@specialize_function("mypy_extensions.i16")
+def translate_i16(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
+    if len(expr.args) != 1 or expr.arg_kinds[0] != ARG_POS:
+        return None
+    arg = expr.args[0]
+    arg_type = builder.node_type(arg)
+    if is_int16_rprimitive(arg_type):
+        return builder.accept(arg)
+    elif is_int32_rprimitive(arg_type) or is_int64_rprimitive(arg_type):
+        val = builder.accept(arg)
+        return builder.add(Truncate(val, int16_rprimitive, line=expr.line))
+    elif is_int_rprimitive(arg_type) or is_bool_rprimitive(arg_type):
+        val = builder.accept(arg)
+        return builder.coerce(val, int16_rprimitive, expr.line)
+    return None
+
+
 @specialize_function("builtins.int")
 def translate_int(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
     if len(expr.args) != 1 or expr.arg_kinds[0] != ARG_POS:
diff --git a/mypyc/lib-rt/CPy.h b/mypyc/lib-rt/CPy.h
index 30d93be609894..689526e0e8266 100644
--- a/mypyc/lib-rt/CPy.h
+++ b/mypyc/lib-rt/CPy.h
@@ -155,6 +155,10 @@ int32_t CPyLong_AsInt32(PyObject *o);
 int32_t CPyInt32_Divide(int32_t x, int32_t y);
 int32_t CPyInt32_Remainder(int32_t x, int32_t y);
 void CPyInt32_Overflow(void);
+int16_t CPyLong_AsInt16(PyObject *o);
+int16_t CPyInt16_Divide(int16_t x, int16_t y);
+int16_t CPyInt16_Remainder(int16_t x, int16_t y);
+void CPyInt16_Overflow(void);
 double CPyTagged_TrueDivide(CPyTagged x, CPyTagged y);
 
 static inline int CPyTagged_CheckLong(CPyTagged x) {
diff --git a/mypyc/lib-rt/int_ops.c b/mypyc/lib-rt/int_ops.c
index 843d9b0d22301..56720d1992e8d 100644
--- a/mypyc/lib-rt/int_ops.c
+++ b/mypyc/lib-rt/int_ops.c
@@ -641,6 +641,75 @@ void CPyInt32_Overflow() {
     PyErr_SetString(PyExc_OverflowError, "int too large to convert to i32");
 }
 
+int16_t CPyLong_AsInt16(PyObject *o) {
+    if (likely(PyLong_Check(o))) {
+        PyLongObject *lobj = (PyLongObject *)o;
+        Py_ssize_t size = lobj->ob_base.ob_size;
+        if (likely(size == 1)) {
+            // Fast path
+            digit x = lobj->ob_digit[0];
+            if (x < 0x8000)
+                return x;
+        } else if (likely(size == 0)) {
+            return 0;
+        }
+    }
+    // Slow path
+    int overflow;
+    long result = PyLong_AsLongAndOverflow(o, &overflow);
+    if (result > 0x7fff || result < -0x8000) {
+        overflow = 1;
+        result = -1;
+    }
+    if (result == -1) {
+        if (PyErr_Occurred()) {
+            return CPY_LL_INT_ERROR;
+        } else if (overflow) {
+            PyErr_SetString(PyExc_OverflowError, "int too large to convert to i16");
+            return CPY_LL_INT_ERROR;
+        }
+    }
+    return result;
+}
+
+int16_t CPyInt16_Divide(int16_t x, int16_t y) {
+    if (y == 0) {
+        PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero");
+        return CPY_LL_INT_ERROR;
+    }
+    if (y == -1 && x == INT16_MIN) {
+        PyErr_SetString(PyExc_OverflowError, "integer division overflow");
+        return CPY_LL_INT_ERROR;
+    }
+    int16_t d = x / y;
+    // Adjust for Python semantics
+    if (((x < 0) != (y < 0)) && d * y != x) {
+        d--;
+    }
+    return d;
+}
+
+int16_t CPyInt16_Remainder(int16_t x, int16_t y) {
+    if (y == 0) {
+        PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero");
+        return CPY_LL_INT_ERROR;
+    }
+    // Edge case: avoid core dump
+    if (y == -1 && x == INT16_MIN) {
+        return 0;
+    }
+    int16_t d = x % y;
+    // Adjust for Python semantics
+    if (((x < 0) != (y < 0)) && d != 0) {
+        d += y;
+    }
+    return d;
+}
+
+void CPyInt16_Overflow() {
+    PyErr_SetString(PyExc_OverflowError, "int too large to convert to i16");
+}
+
 double CPyTagged_TrueDivide(CPyTagged x, CPyTagged y) {
     if (unlikely(y == 0)) {
         PyErr_SetString(PyExc_ZeroDivisionError, "division by zero");
diff --git a/mypyc/primitives/int_ops.py b/mypyc/primitives/int_ops.py
index eff4b4ffd8aba..ef79bbc51ce69 100644
--- a/mypyc/primitives/int_ops.py
+++ b/mypyc/primitives/int_ops.py
@@ -19,6 +19,7 @@
     bool_rprimitive,
     c_pyssize_t_rprimitive,
     float_rprimitive,
+    int16_rprimitive,
     int32_rprimitive,
     int64_rprimitive,
     int_rprimitive,
@@ -37,7 +38,12 @@
 
 # Constructors for builtins.int and native int types have the same behavior. In
 # interpreted mode, native int types are just aliases to 'int'.
-for int_name in ("builtins.int", "mypy_extensions.i64", "mypy_extensions.i32"):
+for int_name in (
+    "builtins.int",
+    "mypy_extensions.i64",
+    "mypy_extensions.i32",
+    "mypy_extensions.i16",
+):
     # These int constructors produce object_rprimitives that then need to be unboxed
     # I guess unboxing ourselves would save a check and branch though?
 
@@ -231,6 +237,20 @@ class IntComparisonOpDescription(NamedTuple):
     error_kind=ERR_MAGIC_OVERLAPPING,
 )
 
+int16_divide_op = custom_op(
+    arg_types=[int16_rprimitive, int16_rprimitive],
+    return_type=int16_rprimitive,
+    c_function_name="CPyInt16_Divide",
+    error_kind=ERR_MAGIC_OVERLAPPING,
+)
+
+int16_mod_op = custom_op(
+    arg_types=[int16_rprimitive, int16_rprimitive],
+    return_type=int16_rprimitive,
+    c_function_name="CPyInt16_Remainder",
+    error_kind=ERR_MAGIC_OVERLAPPING,
+)
+
 # Convert tagged int (as PyObject *) to i64
 int_to_int64_op = custom_op(
     arg_types=[object_rprimitive],
@@ -267,3 +287,10 @@ class IntComparisonOpDescription(NamedTuple):
     c_function_name="CPyInt32_Overflow",
     error_kind=ERR_ALWAYS,
 )
+
+int16_overflow = custom_op(
+    arg_types=[],
+    return_type=void_rtype,
+    c_function_name="CPyInt16_Overflow",
+    error_kind=ERR_ALWAYS,
+)
diff --git a/mypyc/test-data/irbuild-i16.test b/mypyc/test-data/irbuild-i16.test
new file mode 100644
index 0000000000000..0f34ea53818d5
--- /dev/null
+++ b/mypyc/test-data/irbuild-i16.test
@@ -0,0 +1,504 @@
+# Test cases for i16 native ints. Focus on things that are different from i64; no need to
+# duplicate all i64 test cases here.
+
+[case testI16BinaryOp]
+from mypy_extensions import i16
+
+def add_op(x: i16, y: i16) -> i16:
+    x = y + x
+    y = x + 5
+    y += x
+    y += 7
+    x = 5 + y
+    return x
+def compare(x: i16, y: i16) -> None:
+    a = x == y
+    b = x == -5
+    c = x < y
+    d = x < -5
+    e = -5 == x
+    f = -5 < x
+[out]
+def add_op(x, y):
+    x, y, r0, r1, r2, r3, r4 :: int16
+L0:
+    r0 = y + x
+    x = r0
+    r1 = x + 5
+    y = r1
+    r2 = y + x
+    y = r2
+    r3 = y + 7
+    y = r3
+    r4 = 5 + y
+    x = r4
+    return x
+def compare(x, y):
+    x, y :: int16
+    r0 :: bit
+    a :: bool
+    r1 :: bit
+    b :: bool
+    r2 :: bit
+    c :: bool
+    r3 :: bit
+    d :: bool
+    r4 :: bit
+    e :: bool
+    r5 :: bit
+    f :: bool
+L0:
+    r0 = x == y
+    a = r0
+    r1 = x == -5
+    b = r1
+    r2 = x < y :: signed
+    c = r2
+    r3 = x < -5 :: signed
+    d = r3
+    r4 = -5 == x
+    e = r4
+    r5 = -5 < x :: signed
+    f = r5
+    return 1
+
+[case testI16UnaryOp]
+from mypy_extensions import i16
+
+def unary(x: i16) -> i16:
+    y = -x
+    x = ~y
+    y = +x
+    return y
+[out]
+def unary(x):
+    x, r0, y, r1 :: int16
+L0:
+    r0 = 0 - x
+    y = r0
+    r1 = y ^ -1
+    x = r1
+    y = x
+    return y
+
+[case testI16DivisionByConstant]
+from mypy_extensions import i16
+
+def div_by_constant(x: i16) -> i16:
+    x = x // 5
+    x //= 17
+    return x
+[out]
+def div_by_constant(x):
+    x, r0, r1 :: int16
+    r2, r3, r4 :: bit
+    r5 :: int16
+    r6 :: bit
+    r7, r8, r9 :: int16
+    r10, r11, r12 :: bit
+    r13 :: int16
+    r14 :: bit
+    r15 :: int16
+L0:
+    r0 = x / 5
+    r1 = r0
+    r2 = x < 0 :: signed
+    r3 = 5 < 0 :: signed
+    r4 = r2 == r3
+    if r4 goto L3 else goto L1 :: bool
+L1:
+    r5 = r1 * 5
+    r6 = r5 == x
+    if r6 goto L3 else goto L2 :: bool
+L2:
+    r7 = r1 - 1
+    r1 = r7
+L3:
+    x = r1
+    r8 = x / 17
+    r9 = r8
+    r10 = x < 0 :: signed
+    r11 = 17 < 0 :: signed
+    r12 = r10 == r11
+    if r12 goto L6 else goto L4 :: bool
+L4:
+    r13 = r9 * 17
+    r14 = r13 == x
+    if r14 goto L6 else goto L5 :: bool
+L5:
+    r15 = r9 - 1
+    r9 = r15
+L6:
+    x = r9
+    return x
+
+[case testI16ModByConstant]
+from mypy_extensions import i16
+
+def mod_by_constant(x: i16) -> i16:
+    x = x % 5
+    x %= 17
+    return x
+[out]
+def mod_by_constant(x):
+    x, r0, r1 :: int16
+    r2, r3, r4, r5 :: bit
+    r6, r7, r8 :: int16
+    r9, r10, r11, r12 :: bit
+    r13 :: int16
+L0:
+    r0 = x % 5
+    r1 = r0
+    r2 = x < 0 :: signed
+    r3 = 5 < 0 :: signed
+    r4 = r2 == r3
+    if r4 goto L3 else goto L1 :: bool
+L1:
+    r5 = r1 == 0
+    if r5 goto L3 else goto L2 :: bool
+L2:
+    r6 = r1 + 5
+    r1 = r6
+L3:
+    x = r1
+    r7 = x % 17
+    r8 = r7
+    r9 = x < 0 :: signed
+    r10 = 17 < 0 :: signed
+    r11 = r9 == r10
+    if r11 goto L6 else goto L4 :: bool
+L4:
+    r12 = r8 == 0
+    if r12 goto L6 else goto L5 :: bool
+L5:
+    r13 = r8 + 17
+    r8 = r13
+L6:
+    x = r8
+    return x
+
+[case testI16DivModByVariable]
+from mypy_extensions import i16
+
+def divmod(x: i16, y: i16) -> i16:
+    a = x // y
+    return a % y
+[out]
+def divmod(x, y):
+    x, y, r0, a, r1 :: int16
+L0:
+    r0 = CPyInt16_Divide(x, y)
+    a = r0
+    r1 = CPyInt16_Remainder(a, y)
+    return r1
+
+[case testI16BoxAndUnbox]
+from typing import Any
+from mypy_extensions import i16
+
+def f(x: Any) -> Any:
+    y: i16 = x
+    return y
+[out]
+def f(x):
+    x :: object
+    r0, y :: int16
+    r1 :: object
+L0:
+    r0 = unbox(int16, x)
+    y = r0
+    r1 = box(int16, y)
+    return r1
+
+[case testI16MixedCompare1]
+from mypy_extensions import i16
+def f(x: int, y: i16) -> bool:
+    return x == y
+[out]
+def f(x, y):
+    x :: int
+    y :: int16
+    r0 :: native_int
+    r1, r2, r3 :: bit
+    r4 :: native_int
+    r5, r6 :: int16
+    r7 :: bit
+L0:
+    r0 = x & 1
+    r1 = r0 == 0
+    if r1 goto L1 else goto L4 :: bool
+L1:
+    r2 = x < 65536 :: signed
+    if r2 goto L2 else goto L4 :: bool
+L2:
+    r3 = x >= -65536 :: signed
+    if r3 goto L3 else goto L4 :: bool
+L3:
+    r4 = x >> 1
+    r5 = truncate r4: native_int to int16
+    r6 = r5
+    goto L5
+L4:
+    CPyInt16_Overflow()
+    unreachable
+L5:
+    r7 = r6 == y
+    return r7
+
+[case testI16MixedCompare2]
+from mypy_extensions import i16
+def f(x: i16, y: int) -> bool:
+    return x == y
+[out]
+def f(x, y):
+    x :: int16
+    y :: int
+    r0 :: native_int
+    r1, r2, r3 :: bit
+    r4 :: native_int
+    r5, r6 :: int16
+    r7 :: bit
+L0:
+    r0 = y & 1
+    r1 = r0 == 0
+    if r1 goto L1 else goto L4 :: bool
+L1:
+    r2 = y < 65536 :: signed
+    if r2 goto L2 else goto L4 :: bool
+L2:
+    r3 = y >= -65536 :: signed
+    if r3 goto L3 else goto L4 :: bool
+L3:
+    r4 = y >> 1
+    r5 = truncate r4: native_int to int16
+    r6 = r5
+    goto L5
+L4:
+    CPyInt16_Overflow()
+    unreachable
+L5:
+    r7 = x == r6
+    return r7
+
+[case testI16ConvertToInt]
+from mypy_extensions import i16
+
+def i16_to_int(a: i16) -> int:
+    return a
+[out]
+def i16_to_int(a):
+    a :: int16
+    r0 :: native_int
+    r1 :: int
+L0:
+    r0 = extend signed a: int16 to native_int
+    r1 = r0 << 1
+    return r1
+
+[case testI16OperatorAssignmentMixed]
+from mypy_extensions import i16
+
+def f(a: i16) -> None:
+    x = 0
+    x += a
+[out]
+def f(a):
+    a :: int16
+    x :: int
+    r0 :: native_int
+    r1, r2, r3 :: bit
+    r4 :: native_int
+    r5, r6, r7 :: int16
+    r8 :: native_int
+    r9 :: int
+L0:
+    x = 0
+    r0 = x & 1
+    r1 = r0 == 0
+    if r1 goto L1 else goto L4 :: bool
+L1:
+    r2 = x < 65536 :: signed
+    if r2 goto L2 else goto L4 :: bool
+L2:
+    r3 = x >= -65536 :: signed
+    if r3 goto L3 else goto L4 :: bool
+L3:
+    r4 = x >> 1
+    r5 = truncate r4: native_int to int16
+    r6 = r5
+    goto L5
+L4:
+    CPyInt16_Overflow()
+    unreachable
+L5:
+    r7 = r6 + a
+    r8 = extend signed r7: int16 to native_int
+    r9 = r8 << 1
+    x = r9
+    return 1
+
+[case testI16InitializeFromLiteral]
+from mypy_extensions import i16, i64
+
+def f() -> None:
+    x: i16 = 0
+    y: i16 = -127
+    z: i16 = 5 + 7
+[out]
+def f():
+    x, y, z :: int16
+L0:
+    x = 0
+    y = -127
+    z = 12
+    return 1
+
+[case testI16ExplicitConversionFromNativeInt]
+from mypy_extensions import i64, i32, i16
+
+def from_i16(x: i16) -> i16:
+    return i16(x)
+
+def from_i32(x: i32) -> i16:
+    return i16(x)
+
+def from_i64(x: i64) -> i16:
+    return i16(x)
+[out]
+def from_i16(x):
+    x :: int16
+L0:
+    return x
+def from_i32(x):
+    x :: int32
+    r0 :: int16
+L0:
+    r0 = truncate x: int32 to int16
+    return r0
+def from_i64(x):
+    x :: int64
+    r0 :: int16
+L0:
+    r0 = truncate x: int64 to int16
+    return r0
+
+[case testI16ExplicitConversionFromInt]
+from mypy_extensions import i16
+
+def f(x: int) -> i16:
+    return i16(x)
+[out]
+def f(x):
+    x :: int
+    r0 :: native_int
+    r1, r2, r3 :: bit
+    r4 :: native_int
+    r5, r6 :: int16
+L0:
+    r0 = x & 1
+    r1 = r0 == 0
+    if r1 goto L1 else goto L4 :: bool
+L1:
+    r2 = x < 65536 :: signed
+    if r2 goto L2 else goto L4 :: bool
+L2:
+    r3 = x >= -65536 :: signed
+    if r3 goto L3 else goto L4 :: bool
+L3:
+    r4 = x >> 1
+    r5 = truncate r4: native_int to int16
+    r6 = r5
+    goto L5
+L4:
+    CPyInt16_Overflow()
+    unreachable
+L5:
+    return r6
+
+[case testI16ExplicitConversionFromLiteral]
+from mypy_extensions import i16
+
+def f() -> None:
+    x = i16(0)
+    y = i16(11)
+    z = i16(-3)
+[out]
+def f():
+    x, y, z :: int16
+L0:
+    x = 0
+    y = 11
+    z = -3
+    return 1
+
+[case testI16ExplicitConversionFromVariousTypes]
+from mypy_extensions import i16
+
+def bool_to_i16(b: bool) -> i16:
+    return i16(b)
+
+def str_to_i16(s: str) -> i16:
+    return i16(s)
+
+class C:
+    def __int__(self) -> i16:
+        return 5
+
+def instance_to_i16(c: C) -> i16:
+    return i16(c)
+
+def float_to_i16(x: float) -> i16:
+    return i16(x)
+[out]
+def bool_to_i16(b):
+    b :: bool
+    r0 :: int16
+L0:
+    r0 = extend b: builtins.bool to int16
+    return r0
+def str_to_i16(s):
+    s :: str
+    r0 :: object
+    r1 :: int16
+L0:
+    r0 = CPyLong_FromStr(s)
+    r1 = unbox(int16, r0)
+    return r1
+def C.__int__(self):
+    self :: __main__.C
+L0:
+    return 5
+def instance_to_i16(c):
+    c :: __main__.C
+    r0 :: int16
+L0:
+    r0 = c.__int__()
+    return r0
+def float_to_i16(x):
+    x :: float
+    r0 :: int
+    r1 :: native_int
+    r2, r3, r4 :: bit
+    r5 :: native_int
+    r6, r7 :: int16
+L0:
+    r0 = CPyTagged_FromFloat(x)
+    r1 = r0 & 1
+    r2 = r1 == 0
+    if r2 goto L1 else goto L4 :: bool
+L1:
+    r3 = r0 < 65536 :: signed
+    if r3 goto L2 else goto L4 :: bool
+L2:
+    r4 = r0 >= -65536 :: signed
+    if r4 goto L3 else goto L4 :: bool
+L3:
+    r5 = r0 >> 1
+    r6 = truncate r5: native_int to int16
+    r7 = r6
+    goto L5
+L4:
+    CPyInt16_Overflow()
+    unreachable
+L5:
+    return r7
diff --git a/mypyc/test-data/irbuild-i32.test b/mypyc/test-data/irbuild-i32.test
index 725e183657b18..4b69fa3a6bbb0 100644
--- a/mypyc/test-data/irbuild-i32.test
+++ b/mypyc/test-data/irbuild-i32.test
@@ -413,7 +413,10 @@ L0:
     return 1
 
 [case testI32ExplicitConversionFromNativeInt]
-from mypy_extensions import i64, i32
+from mypy_extensions import i64, i32, i16
+
+def from_i16(x: i16) -> i32:
+    return i32(x)
 
 def from_i32(x: i32) -> i32:
     return i32(x)
@@ -421,6 +424,12 @@ def from_i32(x: i32) -> i32:
 def from_i64(x: i64) -> i32:
     return i32(x)
 [out]
+def from_i16(x):
+    x :: int16
+    r0 :: int32
+L0:
+    r0 = extend signed x: int16 to int32
+    return r0
 def from_i32(x):
     x :: int32
 L0:
diff --git a/mypyc/test-data/irbuild-i64.test b/mypyc/test-data/irbuild-i64.test
index a18171c41d574..38561178ddd0a 100644
--- a/mypyc/test-data/irbuild-i64.test
+++ b/mypyc/test-data/irbuild-i64.test
@@ -1506,7 +1506,10 @@ L0:
     return 1
 
 [case testI64ExplicitConversionFromNativeInt]
-from mypy_extensions import i64, i32
+from mypy_extensions import i64, i32, i16
+
+def from_i16(x: i16) -> i64:
+    return i64(x)
 
 def from_i32(x: i32) -> i64:
     return i64(x)
@@ -1514,6 +1517,12 @@ def from_i32(x: i32) -> i64:
 def from_i64(x: i64) -> i64:
     return i64(x)
 [out]
+def from_i16(x):
+    x :: int16
+    r0 :: int64
+L0:
+    r0 = extend signed x: int16 to int64
+    return r0
 def from_i32(x):
     x :: int32
     r0 :: int64
diff --git a/mypyc/test-data/run-i16.test b/mypyc/test-data/run-i16.test
new file mode 100644
index 0000000000000..fbb0c15220bcb
--- /dev/null
+++ b/mypyc/test-data/run-i16.test
@@ -0,0 +1,338 @@
+[case testI16BasicOps]
+from typing import Any, Tuple
+
+from mypy_extensions import i16, i32, i64
+
+from testutil import assertRaises
+
+def test_box_and_unbox() -> None:
+    values = (list(range(-2**15, -2**15 + 100)) +
+              list(range(-1000, 1000)) +
+              list(range(2**15 - 100, 2**15)))
+    for i in values:
+        o: Any = i
+        x: i16 = o
+        o2: Any = x
+        assert o == o2
+        assert x == i
+    with assertRaises(OverflowError, "int too large to convert to i16"):
+        o = 2**15
+        x2: i16 = o
+    with assertRaises(OverflowError, "int too large to convert to i16"):
+        o = -2**15 - 1
+        x3: i16 = o
+
+def div_by_7(x: i16) -> i16:
+    return x // 7
+def div_by_neg_7(x: i16) -> i16:
+    return x // -7
+
+def div(x: i16, y: i16) -> i16:
+    return x // y
+
+def test_divide_by_constant() -> None:
+    for i in range(-1000, 1000):
+        assert div_by_7(i) == i // 7
+    for i in range(-2**15, -2**15 + 1000):
+        assert div_by_7(i) == i // 7
+    for i in range(2**15 - 1000, 2**15):
+        assert div_by_7(i) == i // 7
+
+def test_divide_by_negative_constant() -> None:
+    for i in range(-1000, 1000):
+        assert div_by_neg_7(i) == i // -7
+    for i in range(-2**15, -2**15 + 1000):
+        assert div_by_neg_7(i) == i // -7
+    for i in range(2**15 - 1000, 2**15):
+        assert div_by_neg_7(i) == i // -7
+
+def test_divide_by_variable() -> None:
+    values = (list(range(-50, 50)) +
+              list(range(-2**15, -2**15 + 10)) +
+              list(range(2**15 - 10, 2**15)))
+    for x in values:
+        for y in values:
+            if y != 0:
+                if x // y == 2**15:
+                    with assertRaises(OverflowError, "integer division overflow"):
+                        div(x, y)
+                else:
+                    assert div(x, y) == x // y
+            else:
+                with assertRaises(ZeroDivisionError, "integer division or modulo by zero"):
+                    div(x, y)
+
+def mod_by_7(x: i16) -> i16:
+    return x % 7
+
+def mod_by_neg_7(x: i16) -> i16:
+    return x // -7
+
+def mod(x: i16, y: i16) -> i16:
+    return x % y
+
+def test_mod_by_constant() -> None:
+    for i in range(-1000, 1000):
+        assert mod_by_7(i) == i % 7
+    for i in range(-2**15, -2**15 + 1000):
+        assert mod_by_7(i) == i % 7
+    for i in range(2**15 - 1000, 2**15):
+        assert mod_by_7(i) == i % 7
+
+def test_mod_by_negative_constant() -> None:
+    for i in range(-1000, 1000):
+        assert mod_by_neg_7(i) == i // -7
+    for i in range(-2**15, -2**15 + 1000):
+        assert mod_by_neg_7(i) == i // -7
+    for i in range(2**15 - 1000, 2**15):
+        assert mod_by_neg_7(i) == i // -7
+
+def test_mod_by_variable() -> None:
+    values = (list(range(-50, 50)) +
+              list(range(-2**15, -2**15 + 10)) +
+              list(range(2**15 - 10, 2**15)))
+    for x in values:
+        for y in values:
+            if y != 0:
+                assert mod(x, y) == x % y
+            else:
+                with assertRaises(ZeroDivisionError, "integer division or modulo by zero"):
+                    mod(x, y)
+
+def test_simple_arithmetic_ops() -> None:
+    zero: i16 = int()
+    one: i16 = zero + 1
+    two: i16 = one + 1
+    neg_one: i16 = -one
+    assert one + one == 2
+    assert one + two == 3
+    assert one + neg_one == 0
+    assert one - one == 0
+    assert one - two == -1
+    assert one * one == 1
+    assert one * two == 2
+    assert two * two == 4
+    assert two * neg_one == -2
+    assert neg_one * one == -1
+    assert neg_one * neg_one == 1
+    assert two * 0 == 0
+    assert 0 * two == 0
+    assert -one == -1
+    assert -two == -2
+    assert -neg_one == 1
+    assert -zero == 0
+
+def test_bitwise_ops() -> None:
+    x: i16 = 13855 + int()
+    y: i16 = 367 + int()
+    z: i16 = -11091 + int()
+    zero: i16 = int()
+    one: i16 = zero + 1
+    two: i16 = zero + 2
+    neg_one: i16 = -one
+
+    assert x & y == 15
+    assert x & z == 5133
+    assert z & z == z
+    assert x & zero == 0
+
+    assert x | y == 14207
+    assert x | z == -2369
+    assert z | z == z
+    assert x | 0 == x
+
+    assert x ^ y == 14192
+    assert x ^ z == -7502
+    assert z ^ z == 0
+    assert z ^ 0 == z
+
+    assert x << one == 27710
+    assert x << two == -10116
+    assert z << two == 21172
+    assert z << 0 == z
+
+    assert x >> one == 6927
+    assert x >> two == 3463
+    assert z >> two == -2773
+    assert z >> 0 == z
+
+    assert ~x == -13856
+    assert ~z == 11090
+    assert ~zero == -1
+    assert ~neg_one == 0
+
+def eq(x: i16, y: i16) -> bool:
+    return x == y
+
+def test_eq() -> None:
+    assert eq(int(), int())
+    assert eq(5 + int(), 5 + int())
+    assert eq(-5 + int(), -5 + int())
+    assert not eq(int(), 1 + int())
+    assert not eq(5 + int(), 6 + int())
+    assert not eq(-5 + int(), -6 + int())
+    assert not eq(-5 + int(), 5 + int())
+
+def test_comparisons() -> None:
+    one: i16 = 1 + int()
+    one2: i16 = 1 + int()
+    two: i16 = 2 + int()
+    assert one < two
+    assert not (one < one2)
+    assert not (two < one)
+    assert two > one
+    assert not (one > one2)
+    assert not (one > two)
+    assert one <= two
+    assert one <= one2
+    assert not (two <= one)
+    assert two >= one
+    assert one >= one2
+    assert not (one >= two)
+    assert one == one2
+    assert not (one == two)
+    assert one != two
+    assert not (one != one2)
+
+def test_mixed_comparisons() -> None:
+    i16_3: i16 = int() + 3
+    int_5 = int() + 5
+    assert i16_3 < int_5
+    assert int_5 > i16_3
+    b = i16_3 > int_5
+    assert not b
+
+    int_largest = int() + (1 << 15) - 1
+    assert int_largest > i16_3
+    int_smallest = int() - (1 << 15)
+    assert i16_3 > int_smallest
+
+    int_too_big = int() + (1 << 15)
+    int_too_small = int() - (1 << 15) - 1
+    with assertRaises(OverflowError):
+        assert i16_3 < int_too_big
+    with assertRaises(OverflowError):
+        assert int_too_big < i16_3
+    with assertRaises(OverflowError):
+        assert i16_3 > int_too_small
+    with assertRaises(OverflowError):
+        assert int_too_small < i16_3
+
+def test_mixed_arithmetic_and_bitwise_ops() -> None:
+    i16_3: i16 = int() + 3
+    int_5 = int() + 5
+    assert i16_3 + int_5 == 8
+    assert int_5 - i16_3 == 2
+    assert i16_3 << int_5 == 96
+    assert int_5 << i16_3  == 40
+    assert i16_3 ^ int_5 == 6
+    assert int_5 | i16_3  == 7
+
+    int_largest = int() + (1 << 15) - 1
+    assert int_largest - i16_3 == 32764
+    int_smallest = int() - (1 << 15)
+    assert int_smallest + i16_3 == -32765
+
+    int_too_big = int() + (1 << 15)
+    int_too_small = int() - (1 << 15) - 1
+    with assertRaises(OverflowError):
+        assert i16_3 & int_too_big
+    with assertRaises(OverflowError):
+        assert int_too_small & i16_3
+
+def test_coerce_to_and_from_int() -> None:
+    for shift in range(0, 16):
+        for sign in 1, -1:
+            for delta in range(-5, 5):
+                n = sign * (1 << shift) + delta
+                if -(1 << 15) <= n < (1 << 15):
+                    x: i16 = n
+                    m: int = x
+                    assert m == n
+
+def test_explicit_conversion_to_i16() -> None:
+    x = i16(5)
+    assert x == 5
+    y = int() - 113
+    x = i16(y)
+    assert x == -113
+    n64: i64 = 1733
+    x = i16(n64)
+    assert x == 1733
+    n32: i32 = -1733
+    x = i16(n32)
+    assert x == -1733
+    z = i16(x)
+    assert z == -1733
+
+def test_explicit_conversion_overflow() -> None:
+    max_i16 = int() + 2**15 - 1
+    x = i16(max_i16)
+    assert x == 2**15 - 1
+    assert int(x) == max_i16
+
+    min_i16 = int() - 2**15
+    y = i16(min_i16)
+    assert y == -2**15
+    assert int(y) == min_i16
+
+    too_big = int() + 2**15
+    with assertRaises(OverflowError):
+        x = i16(too_big)
+
+    too_small = int() - 2**15 - 1
+    with assertRaises(OverflowError):
+        x = i16(too_small)
+
+def test_i16_from_large_small_literal() -> None:
+    x = i16(2**15 - 1)
+    assert x == 2**15 - 1
+    x = i16(-2**15)
+    assert x == -2**15
+
+def test_i16_truncate_from_i64() -> None:
+    large = i64(2**32 + 65536 + 157 + int())
+    x = i16(large)
+    assert x == 157
+    small = i64(-2**32 - 65536 - 157 + int())
+    x = i16(small)
+    assert x == -157
+    large2 = i64(2**15 + int())
+    x = i16(large2)
+    assert x == -2**15
+    small2 = i64(-2**15 - 1 - int())
+    x = i16(small2)
+    assert x == 2**15 - 1
+
+def test_i16_truncate_from_i32() -> None:
+    large = i32(2**16 + 2**30 + 5 + int())
+    assert i16(large) == 5
+    small = i32(-2**16 - 2**30 - 1 + int())
+    assert i16(small) == -1
+
+def from_float(x: float) -> i16:
+    return i16(x)
+
+def test_explicit_conversion_from_float() -> None:
+    assert from_float(0.0) == 0
+    assert from_float(1.456) == 1
+    assert from_float(-1234.567) == -1234
+    assert from_float(2**15 - 1) == 2**15 - 1
+    assert from_float(-2**15) == -2**15
+    # The error message could be better, but this is acceptable
+    with assertRaises(OverflowError, "int too large to convert to i16"):
+        assert from_float(float(2**15))
+    with assertRaises(OverflowError, "int too large to convert to i16"):
+        # One ulp below the lowest valid i64 value
+        from_float(float(-2**15 - 1))
+
+def test_tuple_i16() -> None:
+    a: i16 = 1
+    b: i16 = 2
+    t = (a, b)
+    a, b = t
+    assert a == 1
+    assert b == 2
+    x: Any = t
+    tt: Tuple[i16, i16] = x
+    assert tt == (1, 2)
diff --git a/mypyc/test-data/run-i32.test b/mypyc/test-data/run-i32.test
index af99fb79d35e1..bb1fa43bb9fd8 100644
--- a/mypyc/test-data/run-i32.test
+++ b/mypyc/test-data/run-i32.test
@@ -1,7 +1,7 @@
 [case testI32BasicOps]
 from typing import Any, Tuple
 
-from mypy_extensions import i32, i64
+from mypy_extensions import i16, i32, i64
 
 from testutil import assertRaises
 
@@ -259,11 +259,15 @@ def test_explicit_conversion_to_i32() -> None:
     n64: i64 = 1733
     x = i32(n64)
     assert x == 1733
-    n32 = -1733
+    n32: i32 = -1733
     x = i32(n32)
     assert x == -1733
     z = i32(x)
     assert z == -1733
+    a: i16 = int() + 19764
+    assert i32(a) == 19764
+    a = int() - 1
+    assert i32(a) == -1
 
 def test_explicit_conversion_overflow() -> None:
     max_i32 = int() + 2**31 - 1
diff --git a/mypyc/test-data/run-i64.test b/mypyc/test-data/run-i64.test
index bcde39fed5ff1..1a82ac3e2dd12 100644
--- a/mypyc/test-data/run-i64.test
+++ b/mypyc/test-data/run-i64.test
@@ -1,7 +1,7 @@
 [case testI64BasicOps]
 from typing import List, Any, Tuple, Union
 
-from mypy_extensions import i64, i32
+from mypy_extensions import i64, i32, i16
 
 from testutil import assertRaises
 
@@ -282,6 +282,10 @@ def test_explicit_conversion_to_i64() -> None:
     assert x == -1733
     z = i64(x)
     assert z == -1733
+    a: i16 = int() + 19764
+    assert i64(a) == 19764
+    a = int() - 1
+    assert i64(a) == -1
 
 def test_explicit_conversion_overflow() -> None:
     max_i64 = int() + 2**63 - 1
@@ -1500,3 +1504,16 @@ def test_implement_trait_attribute() -> None:
     a.y = 8
     assert a.x == 7
     assert a.y == 8
+
+class DunderErr:
+    def __contains__(self, i: i64) -> bool:
+        raise IndexError()
+
+def test_dunder_arg_check() -> None:
+    o: Any = DunderErr()
+    with assertRaises(TypeError):
+        'x' in o
+    with assertRaises(TypeError):
+        2**63 in o
+    with assertRaises(IndexError):
+        1 in o
diff --git a/mypyc/test/test_irbuild.py b/mypyc/test/test_irbuild.py
index fe347c855661d..2b14619a9884f 100644
--- a/mypyc/test/test_irbuild.py
+++ b/mypyc/test/test_irbuild.py
@@ -42,6 +42,7 @@
     "irbuild-strip-asserts.test",
     "irbuild-i64.test",
     "irbuild-i32.test",
+    "irbuild-i16.test",
     "irbuild-vectorcall.test",
     "irbuild-unreachable.test",
     "irbuild-isinstance.test",
diff --git a/mypyc/test/test_run.py b/mypyc/test/test_run.py
index dc054ac9002f9..a4071b9c3de53 100644
--- a/mypyc/test/test_run.py
+++ b/mypyc/test/test_run.py
@@ -41,6 +41,7 @@
     "run-integers.test",
     "run-i64.test",
     "run-i32.test",
+    "run-i16.test",
     "run-floats.test",
     "run-math.test",
     "run-bools.test",
diff --git a/mypyc/test/test_typeops.py b/mypyc/test/test_typeops.py
index 0d9860d88ffe8..ff2c05ad983e1 100644
--- a/mypyc/test/test_typeops.py
+++ b/mypyc/test/test_typeops.py
@@ -8,6 +8,7 @@
     RUnion,
     bit_rprimitive,
     bool_rprimitive,
+    int16_rprimitive,
     int32_rprimitive,
     int64_rprimitive,
     int_rprimitive,
@@ -18,31 +19,44 @@
 from mypyc.rt_subtype import is_runtime_subtype
 from mypyc.subtype import is_subtype
 
+native_int_types = [int64_rprimitive, int32_rprimitive, int16_rprimitive]
+
 
 class TestSubtype(unittest.TestCase):
     def test_bit(self) -> None:
         assert is_subtype(bit_rprimitive, bool_rprimitive)
         assert is_subtype(bit_rprimitive, int_rprimitive)
         assert is_subtype(bit_rprimitive, short_int_rprimitive)
-        assert is_subtype(bit_rprimitive, int64_rprimitive)
-        assert is_subtype(bit_rprimitive, int32_rprimitive)
+        for rt in native_int_types:
+            assert is_subtype(bit_rprimitive, rt)
 
     def test_bool(self) -> None:
         assert not is_subtype(bool_rprimitive, bit_rprimitive)
         assert is_subtype(bool_rprimitive, int_rprimitive)
         assert is_subtype(bool_rprimitive, short_int_rprimitive)
-        assert is_subtype(bool_rprimitive, int64_rprimitive)
-        assert is_subtype(bool_rprimitive, int32_rprimitive)
+        for rt in native_int_types:
+            assert is_subtype(bool_rprimitive, rt)
 
     def test_int64(self) -> None:
+        assert is_subtype(int64_rprimitive, int64_rprimitive)
         assert is_subtype(int64_rprimitive, int_rprimitive)
         assert not is_subtype(int64_rprimitive, short_int_rprimitive)
         assert not is_subtype(int64_rprimitive, int32_rprimitive)
+        assert not is_subtype(int64_rprimitive, int16_rprimitive)
 
     def test_int32(self) -> None:
+        assert is_subtype(int32_rprimitive, int32_rprimitive)
         assert is_subtype(int32_rprimitive, int_rprimitive)
         assert not is_subtype(int32_rprimitive, short_int_rprimitive)
         assert not is_subtype(int32_rprimitive, int64_rprimitive)
+        assert not is_subtype(int32_rprimitive, int16_rprimitive)
+
+    def test_int16(self) -> None:
+        assert is_subtype(int16_rprimitive, int16_rprimitive)
+        assert is_subtype(int16_rprimitive, int_rprimitive)
+        assert not is_subtype(int16_rprimitive, short_int_rprimitive)
+        assert not is_subtype(int16_rprimitive, int64_rprimitive)
+        assert not is_subtype(int16_rprimitive, int32_rprimitive)
 
 
 class TestRuntimeSubtype(unittest.TestCase):
diff --git a/test-data/unit/lib-stub/mypy_extensions.pyi b/test-data/unit/lib-stub/mypy_extensions.pyi
index 56fac31e72193..b7ff010643158 100644
--- a/test-data/unit/lib-stub/mypy_extensions.pyi
+++ b/test-data/unit/lib-stub/mypy_extensions.pyi
@@ -50,7 +50,37 @@ class FlexibleAlias(Generic[_T, _U]): ...
 class __SupportsInt(Protocol[T_co]):
     def __int__(self) -> int: pass
 
-_Int = Union[int, i32, i64]
+_Int = Union[int, i16, i32, i64]
+
+class i16:
+    def __init__(self, x: Union[_Int, str, bytes, SupportsInt], base: int = 10) -> None: ...
+    def __add__(self, x: i16) -> i16: ...
+    def __radd__(self, x: i16) -> i16: ...
+    def __sub__(self, x: i16) -> i16: ...
+    def __rsub__(self, x: i16) -> i16: ...
+    def __mul__(self, x: i16) -> i16: ...
+    def __rmul__(self, x: i16) -> i16: ...
+    def __floordiv__(self, x: i16) -> i16: ...
+    def __rfloordiv__(self, x: i16) -> i16: ...
+    def __mod__(self, x: i16) -> i16: ...
+    def __rmod__(self, x: i16) -> i16: ...
+    def __and__(self, x: i16) -> i16: ...
+    def __rand__(self, x: i16) -> i16: ...
+    def __or__(self, x: i16) -> i16: ...
+    def __ror__(self, x: i16) -> i16: ...
+    def __xor__(self, x: i16) -> i16: ...
+    def __rxor__(self, x: i16) -> i16: ...
+    def __lshift__(self, x: i16) -> i16: ...
+    def __rlshift__(self, x: i16) -> i16: ...
+    def __rshift__(self, x: i16) -> i16: ...
+    def __rrshift__(self, x: i16) -> i16: ...
+    def __neg__(self) -> i16: ...
+    def __invert__(self) -> i16: ...
+    def __pos__(self) -> i16: ...
+    def __lt__(self, x: i16) -> bool: ...
+    def __le__(self, x: i16) -> bool: ...
+    def __ge__(self, x: i16) -> bool: ...
+    def __gt__(self, x: i16) -> bool: ...
 
 class i32:
     def __init__(self, x: Union[_Int, str, bytes, SupportsInt], base: int = 10) -> None: ...

From c2dc3ff4ee2283f42968aaf2a92bb5dabb05ec01 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Fri, 23 Jun 2023 18:20:57 +0100
Subject: [PATCH 068/129] [mypyc] Fix classes with __dict__ on 3.12 (#15471)

Got this working with a little trial and error.

Work on mypyc/mypyc#995.
---
 mypyc/codegen/emitclass.py | 27 +++++++++++++++++++++++----
 1 file changed, 23 insertions(+), 4 deletions(-)

diff --git a/mypyc/codegen/emitclass.py b/mypyc/codegen/emitclass.py
index eac7a2207972d..3606f5267a8a7 100644
--- a/mypyc/codegen/emitclass.py
+++ b/mypyc/codegen/emitclass.py
@@ -284,8 +284,9 @@ def emit_line() -> None:
 
         fields["tp_members"] = members_name
         fields["tp_basicsize"] = f"{base_size} + 2*sizeof(PyObject *)"
-        fields["tp_dictoffset"] = base_size
-        fields["tp_weaklistoffset"] = weak_offset
+        if emitter.capi_version < (3, 12):
+            fields["tp_dictoffset"] = base_size
+            fields["tp_weaklistoffset"] = weak_offset
     else:
         fields["tp_basicsize"] = base_size
 
@@ -341,6 +342,8 @@ def emit_line() -> None:
             # This is just a placeholder to please CPython. It will be
             # overridden during setup.
             fields["tp_call"] = "PyVectorcall_Call"
+    if has_managed_dict(cl, emitter):
+        flags.append("Py_TPFLAGS_MANAGED_DICT")
     fields["tp_flags"] = " | ".join(flags)
 
     emitter.emit_line(f"static PyTypeObject {emitter.type_struct_name(cl)}_template_ = {{")
@@ -730,7 +733,9 @@ def generate_traverse_for_class(cl: ClassIR, func_name: str, emitter: Emitter) -
     for base in reversed(cl.base_mro):
         for attr, rtype in base.attributes.items():
             emitter.emit_gc_visit(f"self->{emitter.attr(attr)}", rtype)
-    if cl.has_dict:
+    if has_managed_dict(cl, emitter):
+        emitter.emit_line("_PyObject_VisitManagedDict((PyObject *)self, visit, arg);")
+    elif cl.has_dict:
         struct_name = cl.struct_name(emitter.names)
         # __dict__ lives right after the struct and __weakref__ lives right after that
         emitter.emit_gc_visit(
@@ -751,7 +756,9 @@ def generate_clear_for_class(cl: ClassIR, func_name: str, emitter: Emitter) -> N
     for base in reversed(cl.base_mro):
         for attr, rtype in base.attributes.items():
             emitter.emit_gc_clear(f"self->{emitter.attr(attr)}", rtype)
-    if cl.has_dict:
+    if has_managed_dict(cl, emitter):
+        emitter.emit_line("_PyObject_ClearManagedDict((PyObject *)self);")
+    elif cl.has_dict:
         struct_name = cl.struct_name(emitter.names)
         # __dict__ lives right after the struct and __weakref__ lives right after that
         emitter.emit_gc_clear(
@@ -1040,3 +1047,15 @@ def generate_property_setter(
         )
     emitter.emit_line("return 0;")
     emitter.emit_line("}")
+
+
+def has_managed_dict(cl: ClassIR, emitter: Emitter) -> bool:
+    """Should the class get the Py_TPFLAGS_MANAGED_DICT flag?"""
+    # On 3.11 and earlier the flag doesn't exist and we use
+    # tp_dictoffset instead.  If a class inherits from Exception, the
+    # flag conflicts with tp_dictoffset set in the base class.
+    return (
+        emitter.capi_version >= (3, 12)
+        and cl.has_dict
+        and cl.builtin_base != "PyBaseExceptionObject"
+    )

From efe84d492bd77f20c777b523f2e681d1f83f7ac4 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Fri, 23 Jun 2023 18:21:06 +0100
Subject: [PATCH 069/129] [mypyc] Fix generators on Python 3.12 (#15472)

I think we relied on undocumented behavior on older Python versions. Now
it works consistently across all supported Python versions.

Work on mypyc/mypyc#995.
---
 mypyc/lib-rt/exc_ops.c | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/mypyc/lib-rt/exc_ops.c b/mypyc/lib-rt/exc_ops.c
index a7536994d0594..d8307ecf21f85 100644
--- a/mypyc/lib-rt/exc_ops.c
+++ b/mypyc/lib-rt/exc_ops.c
@@ -24,6 +24,12 @@ void CPy_Reraise(void) {
 }
 
 void CPyErr_SetObjectAndTraceback(PyObject *type, PyObject *value, PyObject *traceback) {
+    if (!PyType_Check(type) && value == Py_None) {
+        // The first argument must be an exception instance
+        value = type;
+        type = (PyObject *)Py_TYPE(value);
+    }
+
     // Set the value and traceback of an error. Because calling
     // PyErr_Restore takes away a reference to each object passed in
     // as an argument, we manually increase the reference count of

From ef87305e2aef19c57a3cd485106de825eb45a0c6 Mon Sep 17 00:00:00 2001
From: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
Date: Fri, 23 Jun 2023 18:11:11 -0700
Subject: [PATCH 070/129] Revert "Fix spurious errors on builtins.open
 (#15161)" (#15508)

---
 mypy/semanal_main.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/mypy/semanal_main.py b/mypy/semanal_main.py
index 8e8c455dd6867..d7e9712fa4270 100644
--- a/mypy/semanal_main.py
+++ b/mypy/semanal_main.py
@@ -75,7 +75,6 @@
     "abc",
     "collections",
     "collections.abc",
-    "typing_extensions",
 ]
 
 

From 1fab96bf829c2ff6f1a10e3a47718f77a4a4a5ad Mon Sep 17 00:00:00 2001
From: Nikita Sobolev <mail@sobolevn.me>
Date: Sat, 24 Jun 2023 07:56:46 +0300
Subject: [PATCH 071/129] Remove special handling of `kw_only` in `dataclass`
 plugin serialization (#15502)

It is not needed, because it is always serialized as `bool` and is
always present.

It was added a long time ago in
https://github.com/python/mypy/pull/10867 as a compat layer. But, since
then we've added at least one `is_neither_frozen_nor_nonfrozen`
attribute that is serialized / deserialized in a common way.

So, let's remove this hack for good.
---
 mypy/plugins/dataclasses.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/mypy/plugins/dataclasses.py b/mypy/plugins/dataclasses.py
index 913b1ef233120..cf58e577056c4 100644
--- a/mypy/plugins/dataclasses.py
+++ b/mypy/plugins/dataclasses.py
@@ -158,8 +158,6 @@ def deserialize(
         cls, info: TypeInfo, data: JsonDict, api: SemanticAnalyzerPluginInterface
     ) -> DataclassAttribute:
         data = data.copy()
-        if data.get("kw_only") is None:
-            data["kw_only"] = False
         typ = deserialize_and_fixup_type(data.pop("type"), api)
         return cls(type=typ, info=info, **data)
 

From 9bd85638361de256d732f88396206711c2e10f1d Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Sat, 24 Jun 2023 14:30:27 +0100
Subject: [PATCH 072/129] [mypyc] Fix int operations on Python 3.12 (#15470)

The representation of `int` objects was changed in Python 3.12.

Define some helper macros to make it possible to support all Python
versions we care about without too much code duplication.

Work on https://github.com/mypyc/mypyc/issues/995.

Co-authored-by: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
---
 mypyc/lib-rt/int_ops.c       | 33 ++++++++++++------
 mypyc/lib-rt/mypyc_util.h    | 40 +++++++++++++++++++++
 mypyc/lib-rt/pythonsupport.h | 67 ++++++++++++++++++++++++++++++++++--
 3 files changed, 126 insertions(+), 14 deletions(-)

diff --git a/mypyc/lib-rt/int_ops.c b/mypyc/lib-rt/int_ops.c
index 56720d1992e8d..2a118d99b5eb7 100644
--- a/mypyc/lib-rt/int_ops.c
+++ b/mypyc/lib-rt/int_ops.c
@@ -308,10 +308,10 @@ PyObject *CPyBool_Str(bool b) {
 }
 
 static void CPyLong_NormalizeUnsigned(PyLongObject *v) {
-    Py_ssize_t i = v->ob_base.ob_size;
-    while (i > 0 && v->ob_digit[i - 1] == 0)
+    Py_ssize_t i = CPY_LONG_SIZE_UNSIGNED(v);
+    while (i > 0 && CPY_LONG_DIGIT(v, i - 1) == 0)
         i--;
-    v->ob_base.ob_size = i;
+    CPyLong_SetUnsignedSize(v, i);
 }
 
 // Bitwise op '&', '|' or '^' using the generic (slow) API
@@ -361,8 +361,8 @@ static digit *GetIntDigits(CPyTagged n, Py_ssize_t *size, digit *buf) {
         return buf;
     } else {
         PyLongObject *obj = (PyLongObject *)CPyTagged_LongAsObject(n);
-        *size = obj->ob_base.ob_size;
-        return obj->ob_digit;
+        *size = CPY_LONG_SIZE_SIGNED(obj);
+        return &CPY_LONG_DIGIT(obj, 0);
     }
 }
 
@@ -399,20 +399,20 @@ static CPyTagged BitwiseLongOp(CPyTagged a, CPyTagged b, char op) {
     Py_ssize_t i;
     if (op == '&') {
         for (i = 0; i < asize; i++) {
-            r->ob_digit[i] = adigits[i] & bdigits[i];
+            CPY_LONG_DIGIT(r, i) = adigits[i] & bdigits[i];
         }
     } else {
         if (op == '|') {
             for (i = 0; i < asize; i++) {
-                r->ob_digit[i] = adigits[i] | bdigits[i];
+                CPY_LONG_DIGIT(r, i) = adigits[i] | bdigits[i];
             }
         } else {
             for (i = 0; i < asize; i++) {
-                r->ob_digit[i] = adigits[i] ^ bdigits[i];
+                CPY_LONG_DIGIT(r, i) = adigits[i] ^ bdigits[i];
             }
         }
         for (; i < bsize; i++) {
-            r->ob_digit[i] = bdigits[i];
+            CPY_LONG_DIGIT(r, i) = bdigits[i];
         }
     }
     CPyLong_NormalizeUnsigned(r);
@@ -521,7 +521,7 @@ int64_t CPyLong_AsInt64(PyObject *o) {
         Py_ssize_t size = Py_SIZE(lobj);
         if (likely(size == 1)) {
             // Fast path
-            return lobj->ob_digit[0];
+            return CPY_LONG_DIGIT(lobj, 0);
         } else if (likely(size == 0)) {
             return 0;
         }
@@ -576,14 +576,25 @@ int64_t CPyInt64_Remainder(int64_t x, int64_t y) {
 
 int32_t CPyLong_AsInt32(PyObject *o) {
     if (likely(PyLong_Check(o))) {
+    #if CPY_3_12_FEATURES
+        PyLongObject *lobj = (PyLongObject *)o;
+        size_t tag = CPY_LONG_TAG(lobj);
+        if (likely(tag == (1 << CPY_NON_SIZE_BITS))) {
+            // Fast path
+            return CPY_LONG_DIGIT(lobj, 0);
+        } else if (likely(tag == CPY_SIGN_ZERO)) {
+            return 0;
+        }
+    #else
         PyLongObject *lobj = (PyLongObject *)o;
         Py_ssize_t size = lobj->ob_base.ob_size;
         if (likely(size == 1)) {
             // Fast path
-            return lobj->ob_digit[0];
+            return CPY_LONG_DIGIT(lobj, 0);
         } else if (likely(size == 0)) {
             return 0;
         }
+    #endif
     }
     // Slow path
     int overflow;
diff --git a/mypyc/lib-rt/mypyc_util.h b/mypyc/lib-rt/mypyc_util.h
index 3bc785ac6526b..e7e9fd7687157 100644
--- a/mypyc/lib-rt/mypyc_util.h
+++ b/mypyc/lib-rt/mypyc_util.h
@@ -72,4 +72,44 @@ static inline CPyTagged CPyTagged_ShortFromSsize_t(Py_ssize_t x) {
 // Are we targeting Python 3.12 or newer?
 #define CPY_3_12_FEATURES (PY_VERSION_HEX >= 0x030c0000)
 
+#if CPY_3_12_FEATURES
+
+// Same as macros in CPython internal/pycore_long.h, but with a CPY_ prefix
+#define CPY_NON_SIZE_BITS 3
+#define CPY_SIGN_ZERO 1
+#define CPY_SIGN_NEGATIVE 2
+#define CPY_SIGN_MASK 3
+
+#define CPY_LONG_DIGIT(o, n) ((o)->long_value.ob_digit[n])
+
+// Only available on Python 3.12 and later
+#define CPY_LONG_TAG(o) ((o)->long_value.lv_tag)
+#define CPY_LONG_IS_NEGATIVE(o) (((o)->long_value.lv_tag & CPY_SIGN_MASK) == CPY_SIGN_NEGATIVE)
+// Only available on Python 3.12 and later
+#define CPY_LONG_SIZE(o) ((o)->long_value.lv_tag >> CPY_NON_SIZE_BITS)
+// Number of digits; negative for negative ints
+#define CPY_LONG_SIZE_SIGNED(o) (CPY_LONG_IS_NEGATIVE(o) ? -CPY_LONG_SIZE(o) : CPY_LONG_SIZE(o))
+// Number of digits, assuming int is non-negative
+#define CPY_LONG_SIZE_UNSIGNED(o) CPY_LONG_SIZE(o)
+
+static inline void CPyLong_SetUnsignedSize(PyLongObject *o, Py_ssize_t n) {
+    if (n == 0)
+        o->long_value.lv_tag = CPY_SIGN_ZERO;
+    else
+        o->long_value.lv_tag = n << CPY_NON_SIZE_BITS;
+}
+
+#else
+
+#define CPY_LONG_DIGIT(o, n) ((o)->ob_digit[n])
+#define CPY_LONG_IS_NEGATIVE(o) (((o)->ob_base.ob_size < 0)
+#define CPY_LONG_SIZE_SIGNED(o) ((o)->ob_base.ob_size)
+#define CPY_LONG_SIZE_UNSIGNED(o) ((o)->ob_base.ob_size)
+
+static inline void CPyLong_SetUnsignedSize(PyLongObject *o, Py_ssize_t n) {
+    o->ob_base.ob_size = n;
+}
+
+#endif
+
 #endif
diff --git a/mypyc/lib-rt/pythonsupport.h b/mypyc/lib-rt/pythonsupport.h
index 6751f6f4af02d..1d493b45b89d8 100644
--- a/mypyc/lib-rt/pythonsupport.h
+++ b/mypyc/lib-rt/pythonsupport.h
@@ -129,6 +129,65 @@ init_subclass(PyTypeObject *type, PyObject *kwds)
     return 0;
 }
 
+#if CPY_3_12_FEATURES
+
+static inline Py_ssize_t
+CPyLong_AsSsize_tAndOverflow(PyObject *vv, int *overflow)
+{
+    /* This version by Tim Peters */
+    PyLongObject *v = (PyLongObject *)vv;
+    size_t x, prev;
+    Py_ssize_t res;
+    Py_ssize_t i;
+    int sign;
+
+    *overflow = 0;
+
+    res = -1;
+    i = CPY_LONG_TAG(v);
+
+    // TODO: Combine zero and non-zero cases helow?
+    if (likely(i == (1 << CPY_NON_SIZE_BITS))) {
+        res = CPY_LONG_DIGIT(v, 0);
+    } else if (likely(i == CPY_SIGN_ZERO)) {
+        res = 0;
+    } else if (i == ((1 << CPY_NON_SIZE_BITS) | CPY_SIGN_NEGATIVE)) {
+        res = -(sdigit)CPY_LONG_DIGIT(v, 0);
+    } else {
+        sign = 1;
+        x = 0;
+        if (i & CPY_SIGN_NEGATIVE) {
+            sign = -1;
+        }
+        i >>= CPY_NON_SIZE_BITS;
+        while (--i >= 0) {
+            prev = x;
+            x = (x << PyLong_SHIFT) + CPY_LONG_DIGIT(v, i);
+            if ((x >> PyLong_SHIFT) != prev) {
+                *overflow = sign;
+                goto exit;
+            }
+        }
+        /* Haven't lost any bits, but casting to long requires extra
+         * care (see comment above).
+         */
+        if (x <= (size_t)CPY_TAGGED_MAX) {
+            res = (Py_ssize_t)x * sign;
+        }
+        else if (sign < 0 && x == CPY_TAGGED_ABS_MIN) {
+            res = CPY_TAGGED_MIN;
+        }
+        else {
+            *overflow = sign;
+            /* res is already set to -1 */
+        }
+    }
+  exit:
+    return res;
+}
+
+#else
+
 // Adapted from longobject.c in Python 3.7.0
 
 /* This function adapted from PyLong_AsLongLongAndOverflow, but with
@@ -156,11 +215,11 @@ CPyLong_AsSsize_tAndOverflow(PyObject *vv, int *overflow)
     i = Py_SIZE(v);
 
     if (likely(i == 1)) {
-        res = v->ob_digit[0];
+        res = CPY_LONG_DIGIT(v, 0);
     } else if (likely(i == 0)) {
         res = 0;
     } else if (i == -1) {
-        res = -(sdigit)v->ob_digit[0];
+        res = -(sdigit)CPY_LONG_DIGIT(v, 0);
     } else {
         sign = 1;
         x = 0;
@@ -170,7 +229,7 @@ CPyLong_AsSsize_tAndOverflow(PyObject *vv, int *overflow)
         }
         while (--i >= 0) {
             prev = x;
-            x = (x << PyLong_SHIFT) + v->ob_digit[i];
+            x = (x << PyLong_SHIFT) + CPY_LONG_DIGIT(v, i);
             if ((x >> PyLong_SHIFT) != prev) {
                 *overflow = sign;
                 goto exit;
@@ -194,6 +253,8 @@ CPyLong_AsSsize_tAndOverflow(PyObject *vv, int *overflow)
     return res;
 }
 
+#endif
+
 // Adapted from listobject.c in Python 3.7.0
 static int
 list_resize(PyListObject *self, Py_ssize_t newsize)

From 2bb70781e9c1d5a27b20b8e68980c19ec1ee25fb Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Sun, 25 Jun 2023 10:22:00 +0100
Subject: [PATCH 073/129] [mypyc] Fix i16 on Python 3.12 (#15510)

Two recent mypyc PRs didn't work together (#15470 and #15464). Fix them.
---
 mypyc/lib-rt/int_ops.c | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/mypyc/lib-rt/int_ops.c b/mypyc/lib-rt/int_ops.c
index 2a118d99b5eb7..528401692a3a6 100644
--- a/mypyc/lib-rt/int_ops.c
+++ b/mypyc/lib-rt/int_ops.c
@@ -654,6 +654,18 @@ void CPyInt32_Overflow() {
 
 int16_t CPyLong_AsInt16(PyObject *o) {
     if (likely(PyLong_Check(o))) {
+    #if CPY_3_12_FEATURES
+        PyLongObject *lobj = (PyLongObject *)o;
+        size_t tag = CPY_LONG_TAG(lobj);
+        if (likely(tag == (1 << CPY_NON_SIZE_BITS))) {
+            // Fast path
+            digit x = CPY_LONG_DIGIT(lobj, 0);
+            if (x < 0x8000)
+                return x;
+        } else if (likely(tag == CPY_SIGN_ZERO)) {
+            return 0;
+        }
+    #else
         PyLongObject *lobj = (PyLongObject *)o;
         Py_ssize_t size = lobj->ob_base.ob_size;
         if (likely(size == 1)) {
@@ -664,6 +676,7 @@ int16_t CPyLong_AsInt16(PyObject *o) {
         } else if (likely(size == 0)) {
             return 0;
         }
+    #endif
     }
     // Slow path
     int overflow;

From cee00306a2ded471658b71d2f1c9024bc22a62b1 Mon Sep 17 00:00:00 2001
From: Richard Si <sichard26@gmail.com>
Date: Sun, 25 Jun 2023 05:43:56 -0400
Subject: [PATCH 074/129] Constant fold more unary and binary expressions
 (#15202)

Now mypy can constant fold these additional operations:

- Float arithmetic
- Mixed int and float arithmetic
- String multiplication
- Complex plus or minus a literal real (eg. 1+j2)

While this can be useful with literal types, the main goal is to improve
constant folding in mypyc (mypyc/mypyc#772).

mypyc can also fold bytes addition and multiplication, but mypy cannot
as byte values can't be easily stored anywhere.
---
 mypy/constant_fold.py                      | 118 +++++++--
 mypy/nodes.py                              |   2 +-
 mypy/semanal.py                            |   2 +-
 mypyc/irbuild/builder.py                   |  12 +-
 mypyc/irbuild/callable_class.py            |   2 +-
 mypyc/irbuild/constant_fold.py             |  64 +++--
 mypyc/irbuild/expression.py                |  15 +-
 mypyc/test-data/fixtures/ir.py             |   6 +
 mypyc/test-data/irbuild-basic.test         |   7 +-
 mypyc/test-data/irbuild-constant-fold.test | 281 +++++++++++++++++++--
 10 files changed, 412 insertions(+), 97 deletions(-)

diff --git a/mypy/constant_fold.py b/mypy/constant_fold.py
index a1011397eba88..6881ecae9e885 100644
--- a/mypy/constant_fold.py
+++ b/mypy/constant_fold.py
@@ -8,11 +8,21 @@
 from typing import Union
 from typing_extensions import Final
 
-from mypy.nodes import Expression, FloatExpr, IntExpr, NameExpr, OpExpr, StrExpr, UnaryExpr, Var
+from mypy.nodes import (
+    ComplexExpr,
+    Expression,
+    FloatExpr,
+    IntExpr,
+    NameExpr,
+    OpExpr,
+    StrExpr,
+    UnaryExpr,
+    Var,
+)
 
 # All possible result types of constant folding
-ConstantValue = Union[int, bool, float, str]
-CONST_TYPES: Final = (int, bool, float, str)
+ConstantValue = Union[int, bool, float, complex, str]
+CONST_TYPES: Final = (int, bool, float, complex, str)
 
 
 def constant_fold_expr(expr: Expression, cur_mod_id: str) -> ConstantValue | None:
@@ -39,6 +49,8 @@ def constant_fold_expr(expr: Expression, cur_mod_id: str) -> ConstantValue | Non
         return expr.value
     if isinstance(expr, FloatExpr):
         return expr.value
+    if isinstance(expr, ComplexExpr):
+        return expr.value
     elif isinstance(expr, NameExpr):
         if expr.name == "True":
             return True
@@ -56,26 +68,60 @@ def constant_fold_expr(expr: Expression, cur_mod_id: str) -> ConstantValue | Non
     elif isinstance(expr, OpExpr):
         left = constant_fold_expr(expr.left, cur_mod_id)
         right = constant_fold_expr(expr.right, cur_mod_id)
-        if isinstance(left, int) and isinstance(right, int):
-            return constant_fold_binary_int_op(expr.op, left, right)
-        elif isinstance(left, str) and isinstance(right, str):
-            return constant_fold_binary_str_op(expr.op, left, right)
+        if left is not None and right is not None:
+            return constant_fold_binary_op(expr.op, left, right)
     elif isinstance(expr, UnaryExpr):
         value = constant_fold_expr(expr.expr, cur_mod_id)
-        if isinstance(value, int):
-            return constant_fold_unary_int_op(expr.op, value)
-        if isinstance(value, float):
-            return constant_fold_unary_float_op(expr.op, value)
+        if value is not None:
+            return constant_fold_unary_op(expr.op, value)
     return None
 
 
-def constant_fold_binary_int_op(op: str, left: int, right: int) -> int | None:
+def constant_fold_binary_op(
+    op: str, left: ConstantValue, right: ConstantValue
+) -> ConstantValue | None:
+    if isinstance(left, int) and isinstance(right, int):
+        return constant_fold_binary_int_op(op, left, right)
+
+    # Float and mixed int/float arithmetic.
+    if isinstance(left, float) and isinstance(right, float):
+        return constant_fold_binary_float_op(op, left, right)
+    elif isinstance(left, float) and isinstance(right, int):
+        return constant_fold_binary_float_op(op, left, right)
+    elif isinstance(left, int) and isinstance(right, float):
+        return constant_fold_binary_float_op(op, left, right)
+
+    # String concatenation and multiplication.
+    if op == "+" and isinstance(left, str) and isinstance(right, str):
+        return left + right
+    elif op == "*" and isinstance(left, str) and isinstance(right, int):
+        return left * right
+    elif op == "*" and isinstance(left, int) and isinstance(right, str):
+        return left * right
+
+    # Complex construction.
+    if op == "+" and isinstance(left, (int, float)) and isinstance(right, complex):
+        return left + right
+    elif op == "+" and isinstance(left, complex) and isinstance(right, (int, float)):
+        return left + right
+    elif op == "-" and isinstance(left, (int, float)) and isinstance(right, complex):
+        return left - right
+    elif op == "-" and isinstance(left, complex) and isinstance(right, (int, float)):
+        return left - right
+
+    return None
+
+
+def constant_fold_binary_int_op(op: str, left: int, right: int) -> int | float | None:
     if op == "+":
         return left + right
     if op == "-":
         return left - right
     elif op == "*":
         return left * right
+    elif op == "/":
+        if right != 0:
+            return left / right
     elif op == "//":
         if right != 0:
             return left // right
@@ -102,25 +148,41 @@ def constant_fold_binary_int_op(op: str, left: int, right: int) -> int | None:
     return None
 
 
-def constant_fold_unary_int_op(op: str, value: int) -> int | None:
-    if op == "-":
-        return -value
-    elif op == "~":
-        return ~value
-    elif op == "+":
-        return value
+def constant_fold_binary_float_op(op: str, left: int | float, right: int | float) -> float | None:
+    assert not (isinstance(left, int) and isinstance(right, int)), (op, left, right)
+    if op == "+":
+        return left + right
+    elif op == "-":
+        return left - right
+    elif op == "*":
+        return left * right
+    elif op == "/":
+        if right != 0:
+            return left / right
+    elif op == "//":
+        if right != 0:
+            return left // right
+    elif op == "%":
+        if right != 0:
+            return left % right
+    elif op == "**":
+        if (left < 0 and isinstance(right, int)) or left > 0:
+            try:
+                ret = left**right
+            except OverflowError:
+                return None
+            else:
+                assert isinstance(ret, float), ret
+                return ret
+
     return None
 
 
-def constant_fold_unary_float_op(op: str, value: float) -> float | None:
-    if op == "-":
+def constant_fold_unary_op(op: str, value: ConstantValue) -> int | float | None:
+    if op == "-" and isinstance(value, (int, float)):
         return -value
-    elif op == "+":
+    elif op == "~" and isinstance(value, int):
+        return ~value
+    elif op == "+" and isinstance(value, (int, float)):
         return value
     return None
-
-
-def constant_fold_binary_str_op(op: str, left: str, right: str) -> str | None:
-    if op == "+":
-        return left + right
-    return None
diff --git a/mypy/nodes.py b/mypy/nodes.py
index 2f4f3f7883852..52dd9948e0c1d 100644
--- a/mypy/nodes.py
+++ b/mypy/nodes.py
@@ -1002,7 +1002,7 @@ def __init__(self, name: str, type: mypy.types.Type | None = None) -> None:
         # If constant value is a simple literal,
         # store the literal value (unboxed) for the benefit of
         # tools like mypyc.
-        self.final_value: int | float | bool | str | None = None
+        self.final_value: int | float | complex | bool | str | None = None
         # Where the value was set (only for class attributes)
         self.final_unset_in_class = False
         self.final_set_in_init = False
diff --git a/mypy/semanal.py b/mypy/semanal.py
index 249a57d550b2f..43960d9721012 100644
--- a/mypy/semanal.py
+++ b/mypy/semanal.py
@@ -3394,7 +3394,7 @@ def analyze_simple_literal_type(self, rvalue: Expression, is_final: bool) -> Typ
             return None
 
         value = constant_fold_expr(rvalue, self.cur_mod_id)
-        if value is None:
+        if value is None or isinstance(value, complex):
             return None
 
         if isinstance(value, bool):
diff --git a/mypyc/irbuild/builder.py b/mypyc/irbuild/builder.py
index 26aa17071974f..86c28882d7388 100644
--- a/mypyc/irbuild/builder.py
+++ b/mypyc/irbuild/builder.py
@@ -535,16 +535,14 @@ def load_final_static(
             error_msg=f'value for final name "{error_name}" was not set',
         )
 
-    def load_final_literal_value(self, val: int | str | bytes | float | bool, line: int) -> Value:
-        """Load value of a final name or class-level attribute."""
+    def load_literal_value(self, val: int | str | bytes | float | complex | bool) -> Value:
+        """Load value of a final name, class-level attribute, or constant folded expression."""
         if isinstance(val, bool):
             if val:
                 return self.true()
             else:
                 return self.false()
         elif isinstance(val, int):
-            # TODO: take care of negative integer initializers
-            # (probably easier to fix this in mypy itself).
             return self.builder.load_int(val)
         elif isinstance(val, float):
             return self.builder.load_float(val)
@@ -552,8 +550,10 @@ def load_final_literal_value(self, val: int | str | bytes | float | bool, line:
             return self.builder.load_str(val)
         elif isinstance(val, bytes):
             return self.builder.load_bytes(val)
+        elif isinstance(val, complex):
+            return self.builder.load_complex(val)
         else:
-            assert False, "Unsupported final literal value"
+            assert False, "Unsupported literal value"
 
     def get_assignment_target(
         self, lvalue: Lvalue, line: int = -1, *, for_read: bool = False
@@ -1013,7 +1013,7 @@ def emit_load_final(
             line: line number where loading occurs
         """
         if final_var.final_value is not None:  # this is safe even for non-native names
-            return self.load_final_literal_value(final_var.final_value, line)
+            return self.load_literal_value(final_var.final_value)
         elif native:
             return self.load_final_static(fullname, self.mapper.type_to_rtype(typ), line, name)
         else:
diff --git a/mypyc/irbuild/callable_class.py b/mypyc/irbuild/callable_class.py
index d3ee54a208cd8..599dbb81f7678 100644
--- a/mypyc/irbuild/callable_class.py
+++ b/mypyc/irbuild/callable_class.py
@@ -17,7 +17,7 @@
 
 
 def setup_callable_class(builder: IRBuilder) -> None:
-    """Generate an (incomplete) callable class representing function.
+    """Generate an (incomplete) callable class representing a function.
 
     This can be a nested function or a function within a non-extension
     class.  Also set up the 'self' variable for that class.
diff --git a/mypyc/irbuild/constant_fold.py b/mypyc/irbuild/constant_fold.py
index bc71052f54183..dc21be4689e28 100644
--- a/mypyc/irbuild/constant_fold.py
+++ b/mypyc/irbuild/constant_fold.py
@@ -13,13 +13,10 @@
 from typing import Union
 from typing_extensions import Final
 
-from mypy.constant_fold import (
-    constant_fold_binary_int_op,
-    constant_fold_binary_str_op,
-    constant_fold_unary_float_op,
-    constant_fold_unary_int_op,
-)
+from mypy.constant_fold import constant_fold_binary_op, constant_fold_unary_op
 from mypy.nodes import (
+    BytesExpr,
+    ComplexExpr,
     Expression,
     FloatExpr,
     IntExpr,
@@ -31,10 +28,11 @@
     Var,
 )
 from mypyc.irbuild.builder import IRBuilder
+from mypyc.irbuild.util import bytes_from_str
 
 # All possible result types of constant folding
-ConstantValue = Union[int, str, float]
-CONST_TYPES: Final = (int, str, float)
+ConstantValue = Union[int, float, complex, str, bytes]
+CONST_TYPES: Final = (int, float, complex, str, bytes)
 
 
 def constant_fold_expr(builder: IRBuilder, expr: Expression) -> ConstantValue | None:
@@ -44,35 +42,55 @@ def constant_fold_expr(builder: IRBuilder, expr: Expression) -> ConstantValue |
     """
     if isinstance(expr, IntExpr):
         return expr.value
+    if isinstance(expr, FloatExpr):
+        return expr.value
     if isinstance(expr, StrExpr):
         return expr.value
-    if isinstance(expr, FloatExpr):
+    if isinstance(expr, BytesExpr):
+        return bytes_from_str(expr.value)
+    if isinstance(expr, ComplexExpr):
         return expr.value
     elif isinstance(expr, NameExpr):
         node = expr.node
         if isinstance(node, Var) and node.is_final:
-            value = node.final_value
-            if isinstance(value, (CONST_TYPES)):
-                return value
+            final_value = node.final_value
+            if isinstance(final_value, (CONST_TYPES)):
+                return final_value
     elif isinstance(expr, MemberExpr):
         final = builder.get_final_ref(expr)
         if final is not None:
             fn, final_var, native = final
             if final_var.is_final:
-                value = final_var.final_value
-                if isinstance(value, (CONST_TYPES)):
-                    return value
+                final_value = final_var.final_value
+                if isinstance(final_value, (CONST_TYPES)):
+                    return final_value
     elif isinstance(expr, OpExpr):
         left = constant_fold_expr(builder, expr.left)
         right = constant_fold_expr(builder, expr.right)
-        if isinstance(left, int) and isinstance(right, int):
-            return constant_fold_binary_int_op(expr.op, left, right)
-        elif isinstance(left, str) and isinstance(right, str):
-            return constant_fold_binary_str_op(expr.op, left, right)
+        if left is not None and right is not None:
+            return constant_fold_binary_op_extended(expr.op, left, right)
     elif isinstance(expr, UnaryExpr):
         value = constant_fold_expr(builder, expr.expr)
-        if isinstance(value, int):
-            return constant_fold_unary_int_op(expr.op, value)
-        if isinstance(value, float):
-            return constant_fold_unary_float_op(expr.op, value)
+        if value is not None and not isinstance(value, bytes):
+            return constant_fold_unary_op(expr.op, value)
+    return None
+
+
+def constant_fold_binary_op_extended(
+    op: str, left: ConstantValue, right: ConstantValue
+) -> ConstantValue | None:
+    """Like mypy's constant_fold_binary_op(), but includes bytes support.
+
+    mypy cannot use constant folded bytes easily so it's simpler to only support them in mypyc.
+    """
+    if not isinstance(left, bytes) and not isinstance(right, bytes):
+        return constant_fold_binary_op(op, left, right)
+
+    if op == "+" and isinstance(left, bytes) and isinstance(right, bytes):
+        return left + right
+    elif op == "*" and isinstance(left, bytes) and isinstance(right, int):
+        return left * right
+    elif op == "*" and isinstance(left, int) and isinstance(right, bytes):
+        return left * right
+
     return None
diff --git a/mypyc/irbuild/expression.py b/mypyc/irbuild/expression.py
index 4ebc422ed535d..ada3d47cefab0 100644
--- a/mypyc/irbuild/expression.py
+++ b/mypyc/irbuild/expression.py
@@ -55,7 +55,6 @@
     Assign,
     BasicBlock,
     ComparisonOp,
-    Float,
     Integer,
     LoadAddress,
     LoadLiteral,
@@ -92,7 +91,6 @@
     tokenizer_printf_style,
 )
 from mypyc.irbuild.specialize import apply_function_specialization, apply_method_specialization
-from mypyc.irbuild.util import bytes_from_str
 from mypyc.primitives.bytes_ops import bytes_slice_op
 from mypyc.primitives.dict_ops import dict_get_item_op, dict_new_op, dict_set_item_op
 from mypyc.primitives.generic_ops import iter_op
@@ -575,12 +573,8 @@ def try_constant_fold(builder: IRBuilder, expr: Expression) -> Value | None:
     Return None otherwise.
     """
     value = constant_fold_expr(builder, expr)
-    if isinstance(value, int):
-        return builder.load_int(value)
-    elif isinstance(value, str):
-        return builder.load_str(value)
-    elif isinstance(value, float):
-        return Float(value)
+    if value is not None:
+        return builder.load_literal_value(value)
     return None
 
 
@@ -662,10 +656,6 @@ def set_literal_values(builder: IRBuilder, items: Sequence[Expression]) -> list[
                 values.append(True)
             elif item.fullname == "builtins.False":
                 values.append(False)
-        elif isinstance(item, (BytesExpr, FloatExpr, ComplexExpr)):
-            # constant_fold_expr() doesn't handle these (yet?)
-            v = bytes_from_str(item.value) if isinstance(item, BytesExpr) else item.value
-            values.append(v)
         elif isinstance(item, TupleExpr):
             tuple_values = set_literal_values(builder, item.items)
             if tuple_values is not None:
@@ -685,7 +675,6 @@ def precompute_set_literal(builder: IRBuilder, s: SetExpr) -> Value | None:
     Supported items:
      - Anything supported by irbuild.constant_fold.constant_fold_expr()
      - None, True, and False
-     - Float, byte, and complex literals
      - Tuple literals with only items listed above
     """
     values = set_literal_values(builder, s.items)
diff --git a/mypyc/test-data/fixtures/ir.py b/mypyc/test-data/fixtures/ir.py
index 0b081b079bda9..bf06613ad2a89 100644
--- a/mypyc/test-data/fixtures/ir.py
+++ b/mypyc/test-data/fixtures/ir.py
@@ -87,6 +87,8 @@ def __init__(self) -> None: pass
     @overload
     def __init__(self, x: object) -> None: pass
     def __add__(self, x: str) -> str: pass
+    def __mul__(self, x: int) -> str: pass
+    def __rmul__(self, x: int) -> str: pass
     def __eq__(self, x: object) -> bool: pass
     def __ne__(self, x: object) -> bool: pass
     def __lt__(self, x: str) -> bool: ...
@@ -134,7 +136,9 @@ def __ge__(self, x: float) -> bool: ...
 class complex:
     def __init__(self, x: object, y: object = None) -> None: pass
     def __add__(self, n: complex) -> complex: pass
+    def __radd__(self, n: float) -> complex: pass
     def __sub__(self, n: complex) -> complex: pass
+    def __rsub__(self, n: float) -> complex: pass
     def __mul__(self, n: complex) -> complex: pass
     def __truediv__(self, n: complex) -> complex: pass
     def __neg__(self) -> complex: pass
@@ -145,6 +149,8 @@ def __init__(self) -> None: ...
     @overload
     def __init__(self, x: object) -> None: ...
     def __add__(self, x: bytes) -> bytes: ...
+    def __mul__(self, x: int) -> bytes: ...
+    def __rmul__(self, x: int) -> bytes: ...
     def __eq__(self, x: object) -> bool: ...
     def __ne__(self, x: object) -> bool: ...
     @overload
diff --git a/mypyc/test-data/irbuild-basic.test b/mypyc/test-data/irbuild-basic.test
index 496eca77e0903..556e0a4bbc50f 100644
--- a/mypyc/test-data/irbuild-basic.test
+++ b/mypyc/test-data/irbuild-basic.test
@@ -1172,13 +1172,16 @@ L0:
 
 [case testLoadComplex]
 def load() -> complex:
-    return 5j+1.0
+    real = 1
+    return 5j+real
 [out]
 def load():
+    real :: int
     r0, r1, r2 :: object
 L0:
+    real = 2
     r0 = 5j
-    r1 = box(float, 1.0)
+    r1 = box(int, real)
     r2 = PyNumber_Add(r0, r1)
     return r2
 
diff --git a/mypyc/test-data/irbuild-constant-fold.test b/mypyc/test-data/irbuild-constant-fold.test
index 866953f0c09a6..97b13ab337c73 100644
--- a/mypyc/test-data/irbuild-constant-fold.test
+++ b/mypyc/test-data/irbuild-constant-fold.test
@@ -3,6 +3,7 @@ def bin_ops() -> None:
     add = 15 + 47
     add_mul = (2 + 3) * 5
     sub = 7 - 11
+    div = 3 / 2
     bit_and = 6 & 10
     bit_or = 6 | 10
     bit_xor = 6 ^ 10
@@ -25,11 +26,14 @@ def pow() -> None:
     p3 = 0**0
 [out]
 def bin_ops():
-    add, add_mul, sub, bit_and, bit_or, bit_xor, lshift, rshift, lshift0, rshift0 :: int
+    add, add_mul, sub :: int
+    div :: float
+    bit_and, bit_or, bit_xor, lshift, rshift, lshift0, rshift0 :: int
 L0:
     add = 124
     add_mul = 50
     sub = -8
+    div = 1.5
     bit_and = 4
     bit_or = 28
     bit_xor = 24
@@ -117,35 +121,28 @@ L0:
 
 [case testIntConstantFoldingUnsupportedCases]
 def error_cases() -> None:
-    div_by_zero = 5 // 0
+    div_by_zero = 5 / 0
+    floor_div_by_zero = 5 // 0
     mod_by_zero = 5 % 0
     lshift_neg = 6 << -1
     rshift_neg = 7 >> -1
-def unsupported_div() -> None:
-    x = 4 / 6
-    y = 10 / 5
 def unsupported_pow() -> None:
     p = 3 ** (-1)
 [out]
 def error_cases():
-    r0, div_by_zero, r1, mod_by_zero, r2, lshift_neg, r3, rshift_neg :: int
+    r0, div_by_zero :: float
+    r1, floor_div_by_zero, r2, mod_by_zero, r3, lshift_neg, r4, rshift_neg :: int
 L0:
-    r0 = CPyTagged_FloorDivide(10, 0)
+    r0 = CPyTagged_TrueDivide(10, 0)
     div_by_zero = r0
-    r1 = CPyTagged_Remainder(10, 0)
-    mod_by_zero = r1
-    r2 = CPyTagged_Lshift(12, -2)
-    lshift_neg = r2
-    r3 = CPyTagged_Rshift(14, -2)
-    rshift_neg = r3
-    return 1
-def unsupported_div():
-    r0, x, r1, y :: float
-L0:
-    r0 = CPyTagged_TrueDivide(8, 12)
-    x = r0
-    r1 = CPyTagged_TrueDivide(20, 10)
-    y = r1
+    r1 = CPyTagged_FloorDivide(10, 0)
+    floor_div_by_zero = r1
+    r2 = CPyTagged_Remainder(10, 0)
+    mod_by_zero = r2
+    r3 = CPyTagged_Lshift(12, -2)
+    lshift_neg = r3
+    r4 = CPyTagged_Rshift(14, -2)
+    rshift_neg = r4
     return 1
 def unsupported_pow():
     r0, r1, r2 :: object
@@ -224,20 +221,260 @@ L0:
     a = 12
     return 1
 
+[case testFloatConstantFolding]
+from typing_extensions import Final
+
+N: Final = 1.5
+N2: Final = 1.5 * 2
+
+def bin_ops() -> None:
+    add = 0.5 + 0.5
+    add_mul = (1.5 + 3.5) * 5.0
+    sub = 7.0 - 7.5
+    div = 3.0 / 2.0
+    floor_div = 3.0 // 2.0
+def bin_ops_neg() -> None:
+    add = 0.5 + -0.5
+    add_mul = (-1.5 + 3.5) * -5.0
+    add_mul2 = (1.5 + -3.5) * -5.0
+    sub = 7.0 - -7.5
+    div = 3.0 / -2.0
+    floor_div = 3.0 // -2.0
+def unary_ops() -> None:
+    neg1 = -5.5
+    neg2 = --1.5
+    neg3 = -0.0
+    pos = +5.5
+def pow() -> None:
+    p0 = 16.0**0
+    p1 = 16.0**0.5
+    p2 = (-5.0)**3
+    p3 = 16.0**(-0)
+    p4 = 16.0**(-0.5)
+    p5 = (-2.0)**(-1)
+def error_cases() -> None:
+    div = 2.0 / 0.0
+    floor_div = 2.0 // 0.0
+    power_imag = (-2.0)**0.5
+    power_imag2 = (-2.0)**(-0.5)
+    power_overflow = 2.0**10000.0
+def final_floats() -> None:
+    add1 = N + 1.2
+    add2 = N + N2
+    add3 = -1.2 + N2
+[out]
+def bin_ops():
+    add, add_mul, sub, div, floor_div :: float
+L0:
+    add = 1.0
+    add_mul = 25.0
+    sub = -0.5
+    div = 1.5
+    floor_div = 1.0
+    return 1
+def bin_ops_neg():
+    add, add_mul, add_mul2, sub, div, floor_div :: float
+L0:
+    add = 0.0
+    add_mul = -10.0
+    add_mul2 = 10.0
+    sub = 14.5
+    div = -1.5
+    floor_div = -2.0
+    return 1
+def unary_ops():
+    neg1, neg2, neg3, pos :: float
+L0:
+    neg1 = -5.5
+    neg2 = 1.5
+    neg3 = -0.0
+    pos = 5.5
+    return 1
+def pow():
+    p0, p1, p2, p3, p4, p5 :: float
+L0:
+    p0 = 1.0
+    p1 = 4.0
+    p2 = -125.0
+    p3 = 1.0
+    p4 = 0.25
+    p5 = -0.5
+    return 1
+def error_cases():
+    r0 :: bit
+    r1 :: bool
+    r2, div, r3, floor_div :: float
+    r4, r5, r6 :: object
+    r7, power_imag :: float
+    r8, r9, r10 :: object
+    r11, power_imag2 :: float
+    r12, r13, r14 :: object
+    r15, power_overflow :: float
+L0:
+    r0 = 0.0 == 0.0
+    if r0 goto L1 else goto L2 :: bool
+L1:
+    r1 = raise ZeroDivisionError('float division by zero')
+    unreachable
+L2:
+    r2 = 2.0 / 0.0
+    div = r2
+    r3 = CPyFloat_FloorDivide(2.0, 0.0)
+    floor_div = r3
+    r4 = box(float, -2.0)
+    r5 = box(float, 0.5)
+    r6 = CPyNumber_Power(r4, r5)
+    r7 = unbox(float, r6)
+    power_imag = r7
+    r8 = box(float, -2.0)
+    r9 = box(float, -0.5)
+    r10 = CPyNumber_Power(r8, r9)
+    r11 = unbox(float, r10)
+    power_imag2 = r11
+    r12 = box(float, 2.0)
+    r13 = box(float, 10000.0)
+    r14 = CPyNumber_Power(r12, r13)
+    r15 = unbox(float, r14)
+    power_overflow = r15
+    return 1
+def final_floats():
+    add1, add2, add3 :: float
+L0:
+    add1 = 2.7
+    add2 = 4.5
+    add3 = 1.8
+    return 1
+
+[case testMixedFloatIntConstantFolding]
+def bin_ops() -> None:
+    add = 1 + 0.5
+    sub = 1 - 0.5
+    mul = 0.5 * 5
+    div = 5 / 0.5
+    floor_div = 9.5 // 5
+def error_cases() -> None:
+    div = 2.0 / 0
+    floor_div = 2.0 // 0
+    power_overflow = 2.0**10000
+[out]
+def bin_ops():
+    add, sub, mul, div, floor_div :: float
+L0:
+    add = 1.5
+    sub = 0.5
+    mul = 2.5
+    div = 10.0
+    floor_div = 1.0
+    return 1
+def error_cases():
+    r0 :: bit
+    r1 :: bool
+    r2, div, r3, floor_div :: float
+    r4, r5, r6 :: object
+    r7, power_overflow :: float
+L0:
+    r0 = 0.0 == 0.0
+    if r0 goto L1 else goto L2 :: bool
+L1:
+    r1 = raise ZeroDivisionError('float division by zero')
+    unreachable
+L2:
+    r2 = 2.0 / 0.0
+    div = r2
+    r3 = CPyFloat_FloorDivide(2.0, 0.0)
+    floor_div = r3
+    r4 = box(float, 2.0)
+    r5 = box(float, 10000.0)
+    r6 = CPyNumber_Power(r4, r5)
+    r7 = unbox(float, r6)
+    power_overflow = r7
+    return 1
+
 [case testStrConstantFolding]
 from typing_extensions import Final
 
 S: Final = 'z'
+N: Final = 2
 
 def f() -> None:
     x = 'foo' + 'bar'
     y = 'x' + 'y' + S
+    mul = "foobar" * 2
+    mul2 = N * "foobar"
 [out]
 def f():
-    r0, x, r1, y :: str
+    r0, x, r1, y, r2, mul, r3, mul2 :: str
 L0:
     r0 = 'foobar'
     x = r0
     r1 = 'xyz'
     y = r1
+    r2 = 'foobarfoobar'
+    mul = r2
+    r3 = 'foobarfoobar'
+    mul2 = r3
+    return 1
+
+[case testBytesConstantFolding]
+from typing_extensions import Final
+
+N: Final = 2
+
+def f() -> None:
+    # Unfortunately, mypy doesn't store the bytes value of final refs.
+    x = b'foo' + b'bar'
+    mul = b"foobar" * 2
+    mul2 = N * b"foobar"
+[out]
+def f():
+    r0, x, r1, mul, r2, mul2 :: bytes
+L0:
+    r0 = b'foobar'
+    x = r0
+    r1 = b'foobarfoobar'
+    mul = r1
+    r2 = b'foobarfoobar'
+    mul2 = r2
+    return 1
+
+[case testComplexConstantFolding]
+from typing_extensions import Final
+
+N: Final = 1
+FLOAT_N: Final = 1.5
+
+def integral() -> None:
+    pos = 1+2j
+    pos_2 = 2j+N
+    neg = 1-2j
+    neg_2 = 2j-N
+def floating() -> None:
+    pos = 1.5+2j
+    pos_2 = 2j+FLOAT_N
+    neg = 1.5-2j
+    neg_2 = 2j-FLOAT_N
+[out]
+def integral():
+    r0, pos, r1, pos_2, r2, neg, r3, neg_2 :: object
+L0:
+    r0 = (1+2j)
+    pos = r0
+    r1 = (1+2j)
+    pos_2 = r1
+    r2 = (1-2j)
+    neg = r2
+    r3 = (-1+2j)
+    neg_2 = r3
+    return 1
+def floating():
+    r0, pos, r1, pos_2, r2, neg, r3, neg_2 :: object
+L0:
+    r0 = (1.5+2j)
+    pos = r0
+    r1 = (1.5+2j)
+    pos_2 = r1
+    r2 = (1.5-2j)
+    neg = r2
+    r3 = (-1.5+2j)
+    neg_2 = r3
     return 1

From 9ad3f381ad28be818758e0b24443d36e95b5f943 Mon Sep 17 00:00:00 2001
From: Richard Si <sichard26@gmail.com>
Date: Mon, 26 Jun 2023 02:37:18 -0400
Subject: [PATCH 075/129] Add ReadTheDocs configuration files (#15514)

---
 .readthedocs.yaml       | 18 ++++++++++++++++++
 mypyc/.readthedocs.yaml | 18 ++++++++++++++++++
 2 files changed, 36 insertions(+)
 create mode 100644 .readthedocs.yaml
 create mode 100644 mypyc/.readthedocs.yaml

diff --git a/.readthedocs.yaml b/.readthedocs.yaml
new file mode 100644
index 0000000000000..8ec33ee641ed6
--- /dev/null
+++ b/.readthedocs.yaml
@@ -0,0 +1,18 @@
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+version: 2
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.11"
+
+sphinx:
+   configuration: docs/source/conf.py
+
+formats: [pdf, htmlzip, epub]
+
+python:
+   install:
+   - requirements: docs/requirements-docs.txt
diff --git a/mypyc/.readthedocs.yaml b/mypyc/.readthedocs.yaml
new file mode 100644
index 0000000000000..90831dfd70694
--- /dev/null
+++ b/mypyc/.readthedocs.yaml
@@ -0,0 +1,18 @@
+# Read the Docs configuration file
+# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details
+
+version: 2
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.11"
+
+sphinx:
+   configuration: mypyc/doc/conf.py
+
+formats: [pdf, htmlzip, epub]
+
+python:
+   install:
+   - requirements: docs/requirements-docs.txt

From 9511daa60f53be95bf3b7b67382a4d9862c73b46 Mon Sep 17 00:00:00 2001
From: Nikita Sobolev <mail@sobolevn.me>
Date: Mon, 26 Jun 2023 20:48:01 +0300
Subject: [PATCH 076/129] Support better `__post_init__` method signature for
 `dataclasses` (#15503)

Now we use a similar approach to
https://github.com/python/mypy/pull/14849
First, we generate a private name to store in a metadata (with `-`, so -
no conflicts, ever).
Next, we check override to be compatible: we take the currect signature
and compare it to the ideal one we have.

Simple and it works :)

Closes #15498
Closes #9254

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: Ivan Levkivskyi <levkivskyi@gmail.com>
---
 mypy/checker.py                         |   9 +-
 mypy/message_registry.py                |   1 +
 mypy/messages.py                        |  27 +--
 mypy/plugins/dataclasses.py             |  86 +++++++++-
 test-data/unit/check-dataclasses.test   | 211 ++++++++++++++++++++++++
 test-data/unit/fixtures/dataclasses.pyi |   1 +
 6 files changed, 318 insertions(+), 17 deletions(-)

diff --git a/mypy/checker.py b/mypy/checker.py
index 1026376cce630..cdce42ddaaa1f 100644
--- a/mypy/checker.py
+++ b/mypy/checker.py
@@ -136,6 +136,7 @@
 from mypy.options import Options
 from mypy.patterns import AsPattern, StarredPattern
 from mypy.plugin import CheckerPluginInterface, Plugin
+from mypy.plugins import dataclasses as dataclasses_plugin
 from mypy.scope import Scope
 from mypy.semanal import is_trivial_body, refers_to_fullname, set_callable_name
 from mypy.semanal_enum import ENUM_BASES, ENUM_SPECIAL_PROPS
@@ -1044,6 +1045,9 @@ def check_func_item(
 
         if name == "__exit__":
             self.check__exit__return_type(defn)
+        if name == "__post_init__":
+            if dataclasses_plugin.is_processed_dataclass(defn.info):
+                dataclasses_plugin.check_post_init(self, defn, defn.info)
 
     @contextmanager
     def enter_attribute_inference_context(self) -> Iterator[None]:
@@ -1851,7 +1855,7 @@ def check_method_or_accessor_override_for_base(
                 found_base_method = True
 
             # Check the type of override.
-            if name not in ("__init__", "__new__", "__init_subclass__"):
+            if name not in ("__init__", "__new__", "__init_subclass__", "__post_init__"):
                 # Check method override
                 # (__init__, __new__, __init_subclass__ are special).
                 if self.check_method_override_for_base_with_name(defn, name, base):
@@ -2812,6 +2816,9 @@ def check_assignment(
                 if name == "__match_args__" and inferred is not None:
                     typ = self.expr_checker.accept(rvalue)
                     self.check_match_args(inferred, typ, lvalue)
+                if name == "__post_init__":
+                    if dataclasses_plugin.is_processed_dataclass(self.scope.active_class()):
+                        self.fail(message_registry.DATACLASS_POST_INIT_MUST_BE_A_FUNCTION, rvalue)
 
             # Defer PartialType's super type checking.
             if (
diff --git a/mypy/message_registry.py b/mypy/message_registry.py
index c5164d48fd130..4e08f0dab5eda 100644
--- a/mypy/message_registry.py
+++ b/mypy/message_registry.py
@@ -277,6 +277,7 @@ def with_additional_msg(self, info: str) -> ErrorMessage:
 DATACLASS_FIELD_ALIAS_MUST_BE_LITERAL: Final = (
     '"alias" argument to dataclass field must be a string literal'
 )
+DATACLASS_POST_INIT_MUST_BE_A_FUNCTION: Final = '"__post_init__" method must be an instance method'
 
 # fastparse
 FAILED_TO_MERGE_OVERLOADS: Final = ErrorMessage(
diff --git a/mypy/messages.py b/mypy/messages.py
index 9d703a1a974af..b74a795a4318b 100644
--- a/mypy/messages.py
+++ b/mypy/messages.py
@@ -1253,18 +1253,21 @@ def argument_incompatible_with_supertype(
             code=codes.OVERRIDE,
             secondary_context=secondary_context,
         )
-        self.note(
-            "This violates the Liskov substitution principle",
-            context,
-            code=codes.OVERRIDE,
-            secondary_context=secondary_context,
-        )
-        self.note(
-            "See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides",
-            context,
-            code=codes.OVERRIDE,
-            secondary_context=secondary_context,
-        )
+        if name != "__post_init__":
+            # `__post_init__` is special, it can be incompatible by design.
+            # So, this note is misleading.
+            self.note(
+                "This violates the Liskov substitution principle",
+                context,
+                code=codes.OVERRIDE,
+                secondary_context=secondary_context,
+            )
+            self.note(
+                "See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides",
+                context,
+                code=codes.OVERRIDE,
+                secondary_context=secondary_context,
+            )
 
         if name == "__eq__" and type_name:
             multiline_msg = self.comparison_method_example_msg(class_name=type_name)
diff --git a/mypy/plugins/dataclasses.py b/mypy/plugins/dataclasses.py
index cf58e577056c4..bb3009dddf10b 100644
--- a/mypy/plugins/dataclasses.py
+++ b/mypy/plugins/dataclasses.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Iterator, Optional
+from typing import TYPE_CHECKING, Iterator, Optional
 from typing_extensions import Final
 
 from mypy import errorcodes, message_registry
@@ -26,6 +26,7 @@
     DataclassTransformSpec,
     Expression,
     FuncDef,
+    FuncItem,
     IfStmt,
     JsonDict,
     NameExpr,
@@ -55,6 +56,7 @@
 from mypy.types import (
     AnyType,
     CallableType,
+    FunctionLike,
     Instance,
     LiteralType,
     NoneType,
@@ -69,19 +71,23 @@
 )
 from mypy.typevars import fill_typevars
 
+if TYPE_CHECKING:
+    from mypy.checker import TypeChecker
+
 # The set of decorators that generate dataclasses.
 dataclass_makers: Final = {"dataclass", "dataclasses.dataclass"}
 
 
 SELF_TVAR_NAME: Final = "_DT"
-_TRANSFORM_SPEC_FOR_DATACLASSES = DataclassTransformSpec(
+_TRANSFORM_SPEC_FOR_DATACLASSES: Final = DataclassTransformSpec(
     eq_default=True,
     order_default=False,
     kw_only_default=False,
     frozen_default=False,
     field_specifiers=("dataclasses.Field", "dataclasses.field"),
 )
-_INTERNAL_REPLACE_SYM_NAME = "__mypy-replace"
+_INTERNAL_REPLACE_SYM_NAME: Final = "__mypy-replace"
+_INTERNAL_POST_INIT_SYM_NAME: Final = "__mypy-__post_init__"
 
 
 class DataclassAttribute:
@@ -350,6 +356,8 @@ def transform(self) -> bool:
 
         if self._spec is _TRANSFORM_SPEC_FOR_DATACLASSES:
             self._add_internal_replace_method(attributes)
+        if "__post_init__" in info.names:
+            self._add_internal_post_init_method(attributes)
 
         info.metadata["dataclass"] = {
             "attributes": [attr.serialize() for attr in attributes],
@@ -385,7 +393,47 @@ def _add_internal_replace_method(self, attributes: list[DataclassAttribute]) ->
             fallback=self._api.named_type("builtins.function"),
         )
 
-        self._cls.info.names[_INTERNAL_REPLACE_SYM_NAME] = SymbolTableNode(
+        info.names[_INTERNAL_REPLACE_SYM_NAME] = SymbolTableNode(
+            kind=MDEF, node=FuncDef(typ=signature), plugin_generated=True
+        )
+
+    def _add_internal_post_init_method(self, attributes: list[DataclassAttribute]) -> None:
+        arg_types: list[Type] = [fill_typevars(self._cls.info)]
+        arg_kinds = [ARG_POS]
+        arg_names: list[str | None] = ["self"]
+
+        info = self._cls.info
+        for attr in attributes:
+            if not attr.is_init_var:
+                continue
+            attr_type = attr.expand_type(info)
+            assert attr_type is not None
+            arg_types.append(attr_type)
+            # We always use `ARG_POS` without a default value, because it is practical.
+            # Consider this case:
+            #
+            # @dataclass
+            # class My:
+            #     y: dataclasses.InitVar[str] = 'a'
+            #     def __post_init__(self, y: str) -> None: ...
+            #
+            # We would be *required* to specify `y: str = ...` if default is added here.
+            # But, most people won't care about adding default values to `__post_init__`,
+            # because it is not designed to be called directly, and duplicating default values
+            # for the sake of type-checking is unpleasant.
+            arg_kinds.append(ARG_POS)
+            arg_names.append(attr.name)
+
+        signature = CallableType(
+            arg_types=arg_types,
+            arg_kinds=arg_kinds,
+            arg_names=arg_names,
+            ret_type=NoneType(),
+            fallback=self._api.named_type("builtins.function"),
+            name="__post_init__",
+        )
+
+        info.names[_INTERNAL_POST_INIT_SYM_NAME] = SymbolTableNode(
             kind=MDEF, node=FuncDef(typ=signature), plugin_generated=True
         )
 
@@ -1052,3 +1100,33 @@ def replace_function_sig_callback(ctx: FunctionSigContext) -> CallableType:
         fallback=ctx.default_signature.fallback,
         name=f"{ctx.default_signature.name} of {inst_type_str}",
     )
+
+
+def is_processed_dataclass(info: TypeInfo | None) -> bool:
+    return info is not None and "dataclass" in info.metadata
+
+
+def check_post_init(api: TypeChecker, defn: FuncItem, info: TypeInfo) -> None:
+    if defn.type is None:
+        return
+
+    ideal_sig = info.get_method(_INTERNAL_POST_INIT_SYM_NAME)
+    if ideal_sig is None or ideal_sig.type is None:
+        return
+
+    # We set it ourself, so it is always fine:
+    assert isinstance(ideal_sig.type, ProperType)
+    assert isinstance(ideal_sig.type, FunctionLike)
+    # Type of `FuncItem` is always `FunctionLike`:
+    assert isinstance(defn.type, FunctionLike)
+
+    api.check_override(
+        override=defn.type,
+        original=ideal_sig.type,
+        name="__post_init__",
+        name_in_super="__post_init__",
+        supertype="dataclass",
+        original_class_or_static=False,
+        override_class_or_static=False,
+        node=defn,
+    )
diff --git a/test-data/unit/check-dataclasses.test b/test-data/unit/check-dataclasses.test
index 1f6c8d1432439..4a6e737ddd8d2 100644
--- a/test-data/unit/check-dataclasses.test
+++ b/test-data/unit/check-dataclasses.test
@@ -2197,6 +2197,217 @@ reveal_type(a2)  # N: Revealed type is "__main__.A[builtins.int]"
 a2 = replace(a, x='42')  # E: Argument "x" to "replace" of "A[int]" has incompatible type "str"; expected "int"
 reveal_type(a2)  # N: Revealed type is "__main__.A[builtins.int]"
 
+[case testPostInitCorrectSignature]
+from typing import Any, Generic, TypeVar, Callable, Self
+from dataclasses import dataclass, InitVar
+
+@dataclass
+class Test1:
+    x: int
+    def __post_init__(self) -> None: ...
+
+@dataclass
+class Test2:
+    x: int
+    y: InitVar[int]
+    z: str
+    def __post_init__(self, y: int) -> None: ...
+
+@dataclass
+class Test3:
+    x: InitVar[int]
+    y: InitVar[str]
+    def __post_init__(self, x: int, y: str) -> None: ...
+
+@dataclass
+class Test4:
+    x: int
+    y: InitVar[str]
+    z: InitVar[bool] = True
+    def __post_init__(self, y: str, z: bool) -> None: ...
+
+@dataclass
+class Test5:
+    y: InitVar[str] = 'a'
+    z: InitVar[bool] = True
+    def __post_init__(self, y: str = 'a', z: bool = True) -> None: ...
+
+F = TypeVar('F', bound=Callable[..., Any])
+def identity(f: F) -> F: return f
+
+@dataclass
+class Test6:
+    y: InitVar[str]
+    @identity  # decorated method works
+    def __post_init__(self, y: str) -> None: ...
+
+T = TypeVar('T')
+
+@dataclass
+class Test7(Generic[T]):
+    t: InitVar[T]
+    def __post_init__(self, t: T) -> None: ...
+
+@dataclass
+class Test8:
+    s: InitVar[Self]
+    def __post_init__(self, s: Self) -> None: ...
+[builtins fixtures/dataclasses.pyi]
+
+[case testPostInitSubclassing]
+from dataclasses import dataclass, InitVar
+
+@dataclass
+class Base:
+    a: str
+    x: InitVar[int]
+    def __post_init__(self, x: int) -> None: ...
+
+@dataclass
+class Child(Base):
+    b: str
+    y: InitVar[str]
+    def __post_init__(self, x: int, y: str) -> None: ...
+
+@dataclass
+class GrandChild(Child):
+    c: int
+    z: InitVar[str] = "a"
+    def __post_init__(self, x: int, y: str, z: str) -> None: ...
+[builtins fixtures/dataclasses.pyi]
+
+[case testPostInitNotADataclassCheck]
+from dataclasses import dataclass, InitVar
+
+class Regular:
+    __post_init__ = 1  # can be whatever
+
+class Base:
+    x: InitVar[int]
+    def __post_init__(self) -> None: ...  # can be whatever
+
+@dataclass
+class Child(Base):
+    y: InitVar[str]
+    def __post_init__(self, y: str) -> None: ...
+[builtins fixtures/dataclasses.pyi]
+
+[case testPostInitMissingParam]
+from dataclasses import dataclass, InitVar
+
+@dataclass
+class Child:
+    y: InitVar[str]
+    def __post_init__(self) -> None: ...
+[builtins fixtures/dataclasses.pyi]
+[out]
+main:6: error: Signature of "__post_init__" incompatible with supertype "dataclass"
+main:6: note:      Superclass:
+main:6: note:          def __post_init__(self: Child, y: str) -> None
+main:6: note:      Subclass:
+main:6: note:          def __post_init__(self: Child) -> None
+
+[case testPostInitWrongTypeAndName]
+from dataclasses import dataclass, InitVar
+
+@dataclass
+class Test1:
+    y: InitVar[str]
+    def __post_init__(self, x: int) -> None: ...  # E: Argument 2 of "__post_init__" is incompatible with supertype "dataclass"; supertype defines the argument type as "str"
+
+@dataclass
+class Test2:
+    y: InitVar[str] = 'a'
+    def __post_init__(self, x: int) -> None: ...  # E: Argument 2 of "__post_init__" is incompatible with supertype "dataclass"; supertype defines the argument type as "str"
+[builtins fixtures/dataclasses.pyi]
+
+[case testPostInitExtraParam]
+from dataclasses import dataclass, InitVar
+
+@dataclass
+class Child:
+    y: InitVar[str]
+    def __post_init__(self, y: str, z: int) -> None: ...
+[builtins fixtures/dataclasses.pyi]
+[out]
+main:6: error: Signature of "__post_init__" incompatible with supertype "dataclass"
+main:6: note:      Superclass:
+main:6: note:          def __post_init__(self: Child, y: str) -> None
+main:6: note:      Subclass:
+main:6: note:          def __post_init__(self: Child, y: str, z: int) -> None
+
+[case testPostInitReturnType]
+from dataclasses import dataclass, InitVar
+
+@dataclass
+class Child:
+    y: InitVar[str]
+    def __post_init__(self, y: str) -> int: ...  # E: Return type "int" of "__post_init__" incompatible with return type "None" in supertype "dataclass"
+[builtins fixtures/dataclasses.pyi]
+
+[case testPostInitDecoratedMethodError]
+from dataclasses import dataclass, InitVar
+from typing import Any, Callable, TypeVar
+
+F = TypeVar('F', bound=Callable[..., Any])
+def identity(f: F) -> F: return f
+
+@dataclass
+class Klass:
+    y: InitVar[str]
+    @identity
+    def __post_init__(self) -> None: ...
+[builtins fixtures/dataclasses.pyi]
+[out]
+main:11: error: Signature of "__post_init__" incompatible with supertype "dataclass"
+main:11: note:      Superclass:
+main:11: note:          def __post_init__(self: Klass, y: str) -> None
+main:11: note:      Subclass:
+main:11: note:          def __post_init__(self: Klass) -> None
+
+[case testPostInitIsNotAFunction]
+from dataclasses import dataclass, InitVar
+
+@dataclass
+class Test:
+    y: InitVar[str]
+    __post_init__ = 1  # E: "__post_init__" method must be an instance method
+[builtins fixtures/dataclasses.pyi]
+
+[case testPostInitClassMethod]
+from dataclasses import dataclass, InitVar
+
+@dataclass
+class Test:
+    y: InitVar[str]
+    @classmethod
+    def __post_init__(cls) -> None: ...
+[builtins fixtures/dataclasses.pyi]
+[out]
+main:7: error: Signature of "__post_init__" incompatible with supertype "dataclass"
+main:7: note:      Superclass:
+main:7: note:          def __post_init__(self: Test, y: str) -> None
+main:7: note:      Subclass:
+main:7: note:          @classmethod
+main:7: note:          def __post_init__(cls: Type[Test]) -> None
+
+[case testPostInitStaticMethod]
+from dataclasses import dataclass, InitVar
+
+@dataclass
+class Test:
+    y: InitVar[str]
+    @staticmethod
+    def __post_init__() -> None: ...
+[builtins fixtures/dataclasses.pyi]
+[out]
+main:7: error: Signature of "__post_init__" incompatible with supertype "dataclass"
+main:7: note:      Superclass:
+main:7: note:          def __post_init__(self: Test, y: str) -> None
+main:7: note:      Subclass:
+main:7: note:          @staticmethod
+main:7: note:          def __post_init__() -> None
+
 [case testProtocolNoCrash]
 from typing import Protocol, Union, ClassVar
 from dataclasses import dataclass, field
diff --git a/test-data/unit/fixtures/dataclasses.pyi b/test-data/unit/fixtures/dataclasses.pyi
index 710b8659d2655..059c853a621fa 100644
--- a/test-data/unit/fixtures/dataclasses.pyi
+++ b/test-data/unit/fixtures/dataclasses.pyi
@@ -47,4 +47,5 @@ class list(Generic[_T], Sequence[_T]):
 
 class function: pass
 class classmethod: pass
+class staticmethod: pass
 property = object()

From 7ce3568d823c52e734983333271d315b637a61e6 Mon Sep 17 00:00:00 2001
From: Kyle Benesch <4b796c65+github@gmail.com>
Date: Mon, 26 Jun 2023 13:12:43 -0700
Subject: [PATCH 077/129] Exclude the same special attributes from Protocol as
 CPython (#15490)

---
 mypy/nodes.py                       | 21 ++++++++++
 test-data/unit/check-protocols.test | 64 +++++++++++++++++++++++++++++
 2 files changed, 85 insertions(+)

diff --git a/mypy/nodes.py b/mypy/nodes.py
index 52dd9948e0c1d..212ddb5def377 100644
--- a/mypy/nodes.py
+++ b/mypy/nodes.py
@@ -2802,6 +2802,25 @@ def accept(self, visitor: ExpressionVisitor[T]) -> T:
         return visitor.visit_temp_node(self)
 
 
+# Special attributes not collected as protocol members by Python 3.12
+# See typing._SPECIAL_NAMES
+EXCLUDED_PROTOCOL_ATTRIBUTES: Final = frozenset(
+    {
+        "__abstractmethods__",
+        "__annotations__",
+        "__dict__",
+        "__doc__",
+        "__init__",
+        "__module__",
+        "__new__",
+        "__slots__",
+        "__subclasshook__",
+        "__weakref__",
+        "__class_getitem__",  # Since Python 3.9
+    }
+)
+
+
 class TypeInfo(SymbolNode):
     """The type structure of a single class.
 
@@ -3116,6 +3135,8 @@ def protocol_members(self) -> list[str]:
                     if isinstance(node.node, (TypeAlias, TypeVarExpr, MypyFile)):
                         # These are auxiliary definitions (and type aliases are prohibited).
                         continue
+                    if name in EXCLUDED_PROTOCOL_ATTRIBUTES:
+                        continue
                     members.add(name)
         return sorted(list(members))
 
diff --git a/test-data/unit/check-protocols.test b/test-data/unit/check-protocols.test
index 6976b8ee0a392..6ba1fde4d022f 100644
--- a/test-data/unit/check-protocols.test
+++ b/test-data/unit/check-protocols.test
@@ -2789,6 +2789,70 @@ class A(Protocol):
 
 [builtins fixtures/tuple.pyi]
 
+[case testProtocolSlotsIsNotProtocolMember]
+# https://github.com/python/mypy/issues/11884
+from typing import Protocol
+
+class Foo(Protocol):
+    __slots__ = ()
+class NoSlots:
+    pass
+class EmptySlots:
+    __slots__ = ()
+class TupleSlots:
+    __slots__ = ('x', 'y')
+class StringSlots:
+    __slots__ = 'x y'
+class InitSlots:
+    __slots__ = ('x',)
+    def __init__(self) -> None:
+        self.x = None
+def foo(f: Foo):
+    pass
+
+# All should pass:
+foo(NoSlots())
+foo(EmptySlots())
+foo(TupleSlots())
+foo(StringSlots())
+foo(InitSlots())
+[builtins fixtures/tuple.pyi]
+
+[case testProtocolSlotsAndRuntimeCheckable]
+from typing import Protocol, runtime_checkable
+
+@runtime_checkable
+class Foo(Protocol):
+    __slots__ = ()
+class Bar:
+    pass
+issubclass(Bar, Foo)  # Used to be an error, when `__slots__` counted as a protocol member
+[builtins fixtures/isinstance.pyi]
+[typing fixtures/typing-full.pyi]
+
+
+[case testProtocolWithClassGetItem]
+# https://github.com/python/mypy/issues/11886
+from typing import Any, Iterable, Protocol, Union
+
+class B:
+    ...
+
+class C:
+    def __class_getitem__(cls, __item: Any) -> Any:
+        ...
+
+class SupportsClassGetItem(Protocol):
+    __slots__: Union[str, Iterable[str]] = ()
+    def __class_getitem__(cls, __item: Any) -> Any:
+        ...
+
+b1: SupportsClassGetItem = B()
+c1: SupportsClassGetItem = C()
+[builtins fixtures/tuple.pyi]
+[typing fixtures/typing-full.pyi]
+
+
 [case testNoneVsProtocol]
 # mypy: strict-optional
 from typing_extensions import Protocol

From 8290bb81db80b139185a3543bd459f904841fe44 Mon Sep 17 00:00:00 2001
From: Ivan Levkivskyi <levkivskyi@gmail.com>
Date: Tue, 27 Jun 2023 00:25:59 +0100
Subject: [PATCH 078/129] Support flexible TypedDict creation/update (#15425)

Fixes #9408
Fixes #4122
Fixes #6462
Supersedes #13353

This PR enables two similar technically unsafe behaviors for TypedDicts,
as @JukkaL explained in
https://github.com/python/mypy/issues/6462#issuecomment-466464229
allowing an "incomplete" TypedDict as an argument to `.update()` is
technically unsafe (and a similar argument applies to `**` syntax in
TypedDict literals). These are however very common patterns (judging
from number of duplicates to above issues), so I think we should support
them. Here is what I propose:
* Always support cases that are safe (like passing the type itself to
`update`)
* Allow popular but technically unsafe cases _by default_
* Have a new flag (as part of `--strict`) to fall back to current
behavior

Note that unfortunately we can't use just a custom new error code, since
we need to conditionally tweak some types in a plugin. Btw there are
couple TODOs I add here:
* First is for unsafe behavior for repeated TypedDict keys. This is not
new, I just noticed it when working on this
* Second is for tricky corner case involving multiple `**` items where
we may have false-negatives in strict mode.

Note that I don't test all the possible combinations here (since the
phase space is huge), but I think I am testing all main ingredients (and
I will be glad to add more if needed):
* All syntax variants for TypedDicts creation are handled
* Various shadowing/overrides scenarios
* Required vs non-required keys handling
* Union types (both as item and target types)
* Inference for generic TypedDicts
* New strictness flag

More than half of the tests I took from the original PR #13353
---
 docs/source/command_line.rst                  |  28 ++
 mypy/checkexpr.py                             | 255 ++++++++++---
 mypy/main.py                                  |  13 +-
 mypy/messages.py                              |  18 +
 mypy/options.py                               |   6 +-
 mypy/plugins/default.py                       |  27 ++
 mypy/semanal.py                               |   4 +-
 mypy/subtypes.py                              |  10 +-
 mypy/types.py                                 |   4 +
 .../unit/check-parameter-specification.test   |   2 +-
 test-data/unit/check-typeddict.test           | 361 ++++++++++++++++++
 11 files changed, 659 insertions(+), 69 deletions(-)

diff --git a/docs/source/command_line.rst b/docs/source/command_line.rst
index 2809294092abd..d9de5cd8f9bd3 100644
--- a/docs/source/command_line.rst
+++ b/docs/source/command_line.rst
@@ -612,6 +612,34 @@ of the above sections.
 
        assert text is not None  # OK, check against None is allowed as a special case.
 
+.. option:: --extra-checks
+
+    This flag enables additional checks that are technically correct but may be
+    impractical in real code. In particular, it prohibits partial overlap in
+    ``TypedDict`` updates, and makes arguments prepended via ``Concatenate``
+    positional-only. For example:
+
+    .. code-block:: python
+
+       from typing import TypedDict
+
+       class Foo(TypedDict):
+           a: int
+
+       class Bar(TypedDict):
+           a: int
+           b: int
+
+       def test(foo: Foo, bar: Bar) -> None:
+           # This is technically unsafe since foo can have a subtype of Foo at
+           # runtime, where type of key "b" is incompatible with int, see below
+           bar.update(foo)
+
+       class Bad(Foo):
+           b: str
+       bad: Bad = {"a": 0, "b": "no"}
+       test(bad, bar)
+
 .. option:: --strict
 
     This flag mode enables all optional error checking flags.  You can see the
diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py
index 43896171eadc8..986e58c217620 100644
--- a/mypy/checkexpr.py
+++ b/mypy/checkexpr.py
@@ -4,8 +4,9 @@
 
 import itertools
 import time
+from collections import defaultdict
 from contextlib import contextmanager
-from typing import Callable, ClassVar, Iterator, List, Optional, Sequence, cast
+from typing import Callable, ClassVar, Iterable, Iterator, List, Optional, Sequence, cast
 from typing_extensions import Final, TypeAlias as _TypeAlias, overload
 
 import mypy.checker
@@ -695,74 +696,183 @@ def check_typeddict_call(
         context: Context,
         orig_callee: Type | None,
     ) -> Type:
-        if args and all([ak == ARG_NAMED for ak in arg_kinds]):
-            # ex: Point(x=42, y=1337)
-            assert all(arg_name is not None for arg_name in arg_names)
-            item_names = cast(List[str], arg_names)
-            item_args = args
-            return self.check_typeddict_call_with_kwargs(
-                callee, dict(zip(item_names, item_args)), context, orig_callee
-            )
+        if args and all([ak in (ARG_NAMED, ARG_STAR2) for ak in arg_kinds]):
+            # ex: Point(x=42, y=1337, **extras)
+            # This is a bit ugly, but this is a price for supporting all possible syntax
+            # variants for TypedDict constructors.
+            kwargs = zip([StrExpr(n) if n is not None else None for n in arg_names], args)
+            result = self.validate_typeddict_kwargs(kwargs=kwargs, callee=callee)
+            if result is not None:
+                validated_kwargs, always_present_keys = result
+                return self.check_typeddict_call_with_kwargs(
+                    callee, validated_kwargs, context, orig_callee, always_present_keys
+                )
+            return AnyType(TypeOfAny.from_error)
 
         if len(args) == 1 and arg_kinds[0] == ARG_POS:
             unique_arg = args[0]
             if isinstance(unique_arg, DictExpr):
-                # ex: Point({'x': 42, 'y': 1337})
+                # ex: Point({'x': 42, 'y': 1337, **extras})
                 return self.check_typeddict_call_with_dict(
-                    callee, unique_arg, context, orig_callee
+                    callee, unique_arg.items, context, orig_callee
                 )
             if isinstance(unique_arg, CallExpr) and isinstance(unique_arg.analyzed, DictExpr):
-                # ex: Point(dict(x=42, y=1337))
+                # ex: Point(dict(x=42, y=1337, **extras))
                 return self.check_typeddict_call_with_dict(
-                    callee, unique_arg.analyzed, context, orig_callee
+                    callee, unique_arg.analyzed.items, context, orig_callee
                 )
 
         if not args:
             # ex: EmptyDict()
-            return self.check_typeddict_call_with_kwargs(callee, {}, context, orig_callee)
+            return self.check_typeddict_call_with_kwargs(callee, {}, context, orig_callee, set())
 
         self.chk.fail(message_registry.INVALID_TYPEDDICT_ARGS, context)
         return AnyType(TypeOfAny.from_error)
 
-    def validate_typeddict_kwargs(self, kwargs: DictExpr) -> dict[str, Expression] | None:
-        item_args = [item[1] for item in kwargs.items]
-
-        item_names = []  # List[str]
-        for item_name_expr, item_arg in kwargs.items:
-            literal_value = None
+    def validate_typeddict_kwargs(
+        self, kwargs: Iterable[tuple[Expression | None, Expression]], callee: TypedDictType
+    ) -> tuple[dict[str, list[Expression]], set[str]] | None:
+        # All (actual or mapped from ** unpacks) expressions that can match given key.
+        result = defaultdict(list)
+        # Keys that are guaranteed to be present no matter what (e.g. for all items of a union)
+        always_present_keys = set()
+        # Indicates latest encountered ** unpack among items.
+        last_star_found = None
+
+        for item_name_expr, item_arg in kwargs:
             if item_name_expr:
                 key_type = self.accept(item_name_expr)
                 values = try_getting_str_literals(item_name_expr, key_type)
+                literal_value = None
                 if values and len(values) == 1:
                     literal_value = values[0]
-            if literal_value is None:
-                key_context = item_name_expr or item_arg
-                self.chk.fail(
-                    message_registry.TYPEDDICT_KEY_MUST_BE_STRING_LITERAL,
-                    key_context,
-                    code=codes.LITERAL_REQ,
-                )
-                return None
+                if literal_value is None:
+                    key_context = item_name_expr or item_arg
+                    self.chk.fail(
+                        message_registry.TYPEDDICT_KEY_MUST_BE_STRING_LITERAL,
+                        key_context,
+                        code=codes.LITERAL_REQ,
+                    )
+                    return None
+                else:
+                    # A directly present key unconditionally shadows all previously found
+                    # values from ** items.
+                    # TODO: for duplicate keys, type-check all values.
+                    result[literal_value] = [item_arg]
+                    always_present_keys.add(literal_value)
             else:
-                item_names.append(literal_value)
-        return dict(zip(item_names, item_args))
+                last_star_found = item_arg
+                if not self.validate_star_typeddict_item(
+                    item_arg, callee, result, always_present_keys
+                ):
+                    return None
+        if self.chk.options.extra_checks and last_star_found is not None:
+            absent_keys = []
+            for key in callee.items:
+                if key not in callee.required_keys and key not in result:
+                    absent_keys.append(key)
+            if absent_keys:
+                # Having an optional key not explicitly declared by a ** unpacked
+                # TypedDict is unsafe, it may be an (incompatible) subtype at runtime.
+                # TODO: catch the cases where a declared key is overridden by a subsequent
+                # ** item without it (and not again overriden with complete ** item).
+                self.msg.non_required_keys_absent_with_star(absent_keys, last_star_found)
+        return result, always_present_keys
+
+    def validate_star_typeddict_item(
+        self,
+        item_arg: Expression,
+        callee: TypedDictType,
+        result: dict[str, list[Expression]],
+        always_present_keys: set[str],
+    ) -> bool:
+        """Update keys/expressions from a ** expression in TypedDict constructor.
+
+        Note `result` and `always_present_keys` are updated in place. Return true if the
+        expression `item_arg` may valid in `callee` TypedDict context.
+        """
+        with self.chk.local_type_map(), self.msg.filter_errors():
+            inferred = get_proper_type(self.accept(item_arg, type_context=callee))
+        possible_tds = []
+        if isinstance(inferred, TypedDictType):
+            possible_tds = [inferred]
+        elif isinstance(inferred, UnionType):
+            for item in get_proper_types(inferred.relevant_items()):
+                if isinstance(item, TypedDictType):
+                    possible_tds.append(item)
+                elif not self.valid_unpack_fallback_item(item):
+                    self.msg.unsupported_target_for_star_typeddict(item, item_arg)
+                    return False
+        elif not self.valid_unpack_fallback_item(inferred):
+            self.msg.unsupported_target_for_star_typeddict(inferred, item_arg)
+            return False
+        all_keys: set[str] = set()
+        for td in possible_tds:
+            all_keys |= td.items.keys()
+        for key in all_keys:
+            arg = TempNode(
+                UnionType.make_union([td.items[key] for td in possible_tds if key in td.items])
+            )
+            arg.set_line(item_arg)
+            if all(key in td.required_keys for td in possible_tds):
+                always_present_keys.add(key)
+                # Always present keys override previously found values. This is done
+                # to support use cases like `Config({**defaults, **overrides})`, where
+                # some `overrides` types are narrower that types in `defaults`, and
+                # former are too wide for `Config`.
+                if result[key]:
+                    first = result[key][0]
+                    if not isinstance(first, TempNode):
+                        # We must always preserve any non-synthetic values, so that
+                        # we will accept them even if they are shadowed.
+                        result[key] = [first, arg]
+                    else:
+                        result[key] = [arg]
+                else:
+                    result[key] = [arg]
+            else:
+                # If this key is not required at least in some item of a union
+                # it may not shadow previous item, so we need to type check both.
+                result[key].append(arg)
+        return True
+
+    def valid_unpack_fallback_item(self, typ: ProperType) -> bool:
+        if isinstance(typ, AnyType):
+            return True
+        if not isinstance(typ, Instance) or not typ.type.has_base("typing.Mapping"):
+            return False
+        mapped = map_instance_to_supertype(typ, self.chk.lookup_typeinfo("typing.Mapping"))
+        return all(isinstance(a, AnyType) for a in get_proper_types(mapped.args))
 
     def match_typeddict_call_with_dict(
-        self, callee: TypedDictType, kwargs: DictExpr, context: Context
+        self,
+        callee: TypedDictType,
+        kwargs: list[tuple[Expression | None, Expression]],
+        context: Context,
     ) -> bool:
-        validated_kwargs = self.validate_typeddict_kwargs(kwargs=kwargs)
-        if validated_kwargs is not None:
+        result = self.validate_typeddict_kwargs(kwargs=kwargs, callee=callee)
+        if result is not None:
+            validated_kwargs, _ = result
             return callee.required_keys <= set(validated_kwargs.keys()) <= set(callee.items.keys())
         else:
             return False
 
     def check_typeddict_call_with_dict(
-        self, callee: TypedDictType, kwargs: DictExpr, context: Context, orig_callee: Type | None
+        self,
+        callee: TypedDictType,
+        kwargs: list[tuple[Expression | None, Expression]],
+        context: Context,
+        orig_callee: Type | None,
     ) -> Type:
-        validated_kwargs = self.validate_typeddict_kwargs(kwargs=kwargs)
-        if validated_kwargs is not None:
+        result = self.validate_typeddict_kwargs(kwargs=kwargs, callee=callee)
+        if result is not None:
+            validated_kwargs, always_present_keys = result
             return self.check_typeddict_call_with_kwargs(
-                callee, kwargs=validated_kwargs, context=context, orig_callee=orig_callee
+                callee,
+                kwargs=validated_kwargs,
+                context=context,
+                orig_callee=orig_callee,
+                always_present_keys=always_present_keys,
             )
         else:
             return AnyType(TypeOfAny.from_error)
@@ -803,20 +913,37 @@ def typeddict_callable_from_context(self, callee: TypedDictType) -> CallableType
     def check_typeddict_call_with_kwargs(
         self,
         callee: TypedDictType,
-        kwargs: dict[str, Expression],
+        kwargs: dict[str, list[Expression]],
         context: Context,
         orig_callee: Type | None,
+        always_present_keys: set[str],
     ) -> Type:
         actual_keys = kwargs.keys()
-        if not (callee.required_keys <= actual_keys <= callee.items.keys()):
-            expected_keys = [
-                key
-                for key in callee.items.keys()
-                if key in callee.required_keys or key in actual_keys
-            ]
-            self.msg.unexpected_typeddict_keys(
-                callee, expected_keys=expected_keys, actual_keys=list(actual_keys), context=context
-            )
+        if not (
+            callee.required_keys <= always_present_keys and actual_keys <= callee.items.keys()
+        ):
+            if not (actual_keys <= callee.items.keys()):
+                self.msg.unexpected_typeddict_keys(
+                    callee,
+                    expected_keys=[
+                        key
+                        for key in callee.items.keys()
+                        if key in callee.required_keys or key in actual_keys
+                    ],
+                    actual_keys=list(actual_keys),
+                    context=context,
+                )
+            if not (callee.required_keys <= always_present_keys):
+                self.msg.unexpected_typeddict_keys(
+                    callee,
+                    expected_keys=[
+                        key for key in callee.items.keys() if key in callee.required_keys
+                    ],
+                    actual_keys=[
+                        key for key in always_present_keys if key in callee.required_keys
+                    ],
+                    context=context,
+                )
             if callee.required_keys > actual_keys:
                 # found_set is a sub-set of the required_keys
                 # This means we're missing some keys and as such, we can't
@@ -839,7 +966,10 @@ def check_typeddict_call_with_kwargs(
         with self.msg.filter_errors(), self.chk.local_type_map():
             orig_ret_type, _ = self.check_callable_call(
                 infer_callee,
-                list(kwargs.values()),
+                # We use first expression for each key to infer type variables of a generic
+                # TypedDict. This is a bit arbitrary, but in most cases will work better than
+                # trying to infer a union or a join.
+                [args[0] for args in kwargs.values()],
                 [ArgKind.ARG_NAMED] * len(kwargs),
                 context,
                 list(kwargs.keys()),
@@ -856,17 +986,18 @@ def check_typeddict_call_with_kwargs(
 
         for item_name, item_expected_type in ret_type.items.items():
             if item_name in kwargs:
-                item_value = kwargs[item_name]
-                self.chk.check_simple_assignment(
-                    lvalue_type=item_expected_type,
-                    rvalue=item_value,
-                    context=item_value,
-                    msg=ErrorMessage(
-                        message_registry.INCOMPATIBLE_TYPES.value, code=codes.TYPEDDICT_ITEM
-                    ),
-                    lvalue_name=f'TypedDict item "{item_name}"',
-                    rvalue_name="expression",
-                )
+                item_values = kwargs[item_name]
+                for item_value in item_values:
+                    self.chk.check_simple_assignment(
+                        lvalue_type=item_expected_type,
+                        rvalue=item_value,
+                        context=item_value,
+                        msg=ErrorMessage(
+                            message_registry.INCOMPATIBLE_TYPES.value, code=codes.TYPEDDICT_ITEM
+                        ),
+                        lvalue_name=f'TypedDict item "{item_name}"',
+                        rvalue_name="expression",
+                    )
 
         return orig_ret_type
 
@@ -4382,7 +4513,7 @@ def check_typeddict_literal_in_context(
         self, e: DictExpr, typeddict_context: TypedDictType
     ) -> Type:
         orig_ret_type = self.check_typeddict_call_with_dict(
-            callee=typeddict_context, kwargs=e, context=e, orig_callee=None
+            callee=typeddict_context, kwargs=e.items, context=e, orig_callee=None
         )
         ret_type = get_proper_type(orig_ret_type)
         if isinstance(ret_type, TypedDictType):
@@ -4482,7 +4613,9 @@ def find_typeddict_context(
             for item in context.items:
                 item_contexts = self.find_typeddict_context(item, dict_expr)
                 for item_context in item_contexts:
-                    if self.match_typeddict_call_with_dict(item_context, dict_expr, dict_expr):
+                    if self.match_typeddict_call_with_dict(
+                        item_context, dict_expr.items, dict_expr
+                    ):
                         items.append(item_context)
             return items
         # No TypedDict type in context.
diff --git a/mypy/main.py b/mypy/main.py
index b60c5b2a6bba3..22ff3e32a718a 100644
--- a/mypy/main.py
+++ b/mypy/main.py
@@ -826,10 +826,12 @@ def add_invertible_flag(
     )
 
     add_invertible_flag(
-        "--strict-concatenate",
+        "--extra-checks",
         default=False,
         strict_flag=True,
-        help="Make arguments prepended via Concatenate be truly positional-only",
+        help="Enable additional checks that are technically correct but may be impractical "
+        "in real code. For example, this prohibits partial overlap in TypedDict updates, "
+        "and makes arguments prepended via Concatenate positional-only",
         group=strictness_group,
     )
 
@@ -1155,6 +1157,8 @@ def add_invertible_flag(
     parser.add_argument(
         "--disable-memoryview-promotion", action="store_true", help=argparse.SUPPRESS
     )
+    # This flag is deprecated, it has been moved to --extra-checks
+    parser.add_argument("--strict-concatenate", action="store_true", help=argparse.SUPPRESS)
 
     # options specifying code to check
     code_group = parser.add_argument_group(
@@ -1226,8 +1230,11 @@ def add_invertible_flag(
         parser.error(f"Cannot find config file '{config_file}'")
 
     options = Options()
+    strict_option_set = False
 
     def set_strict_flags() -> None:
+        nonlocal strict_option_set
+        strict_option_set = True
         for dest, value in strict_flag_assignments:
             setattr(options, dest, value)
 
@@ -1379,6 +1386,8 @@ def set_strict_flags() -> None:
             "Warning: --enable-recursive-aliases is deprecated;"
             " recursive types are enabled by default"
         )
+    if options.strict_concatenate and not strict_option_set:
+        print("Warning: --strict-concatenate is deprecated; use --extra-checks instead")
 
     # Set target.
     if special_opts.modules + special_opts.packages:
diff --git a/mypy/messages.py b/mypy/messages.py
index b74a795a4318b..ea7923c597782 100644
--- a/mypy/messages.py
+++ b/mypy/messages.py
@@ -1757,6 +1757,24 @@ def need_annotation_for_var(
     def explicit_any(self, ctx: Context) -> None:
         self.fail('Explicit "Any" is not allowed', ctx)
 
+    def unsupported_target_for_star_typeddict(self, typ: Type, ctx: Context) -> None:
+        self.fail(
+            "Unsupported type {} for ** expansion in TypedDict".format(
+                format_type(typ, self.options)
+            ),
+            ctx,
+            code=codes.TYPEDDICT_ITEM,
+        )
+
+    def non_required_keys_absent_with_star(self, keys: list[str], ctx: Context) -> None:
+        self.fail(
+            "Non-required {} not explicitly found in any ** item".format(
+                format_key_list(keys, short=True)
+            ),
+            ctx,
+            code=codes.TYPEDDICT_ITEM,
+        )
+
     def unexpected_typeddict_keys(
         self,
         typ: TypedDictType,
diff --git a/mypy/options.py b/mypy/options.py
index f75734124eb0f..e1d731c1124c5 100644
--- a/mypy/options.py
+++ b/mypy/options.py
@@ -40,6 +40,7 @@ class BuildType:
     "disallow_untyped_defs",
     "enable_error_code",
     "enabled_error_codes",
+    "extra_checks",
     "follow_imports_for_stubs",
     "follow_imports",
     "ignore_errors",
@@ -200,9 +201,12 @@ def __init__(self) -> None:
         # This makes 1 == '1', 1 in ['1'], and 1 is '1' errors.
         self.strict_equality = False
 
-        # Make arguments prepended via Concatenate be truly positional-only.
+        # Deprecated, use extra_checks instead.
         self.strict_concatenate = False
 
+        # Enable additional checks that are technically correct but impractical.
+        self.extra_checks = False
+
         # Report an error for any branches inferred to be unreachable as a result of
         # type analysis.
         self.warn_unreachable = False
diff --git a/mypy/plugins/default.py b/mypy/plugins/default.py
index b83c0192a14b7..f5dea0621177f 100644
--- a/mypy/plugins/default.py
+++ b/mypy/plugins/default.py
@@ -31,7 +31,9 @@
     TypedDictType,
     TypeOfAny,
     TypeVarType,
+    UnionType,
     get_proper_type,
+    get_proper_types,
 )
 
 
@@ -404,6 +406,31 @@ def typed_dict_update_signature_callback(ctx: MethodSigContext) -> CallableType:
         assert isinstance(arg_type, TypedDictType)
         arg_type = arg_type.as_anonymous()
         arg_type = arg_type.copy_modified(required_keys=set())
+        if ctx.args and ctx.args[0]:
+            with ctx.api.msg.filter_errors():
+                inferred = get_proper_type(
+                    ctx.api.get_expression_type(ctx.args[0][0], type_context=arg_type)
+                )
+            possible_tds = []
+            if isinstance(inferred, TypedDictType):
+                possible_tds = [inferred]
+            elif isinstance(inferred, UnionType):
+                possible_tds = [
+                    t
+                    for t in get_proper_types(inferred.relevant_items())
+                    if isinstance(t, TypedDictType)
+                ]
+            items = []
+            for td in possible_tds:
+                item = arg_type.copy_modified(
+                    required_keys=(arg_type.required_keys | td.required_keys)
+                    & arg_type.items.keys()
+                )
+                if not ctx.api.options.extra_checks:
+                    item = item.copy_modified(item_names=list(td.items))
+                items.append(item)
+            if items:
+                arg_type = make_simplified_union(items)
         return signature.copy_modified(arg_types=[arg_type])
     return signature
 
diff --git a/mypy/semanal.py b/mypy/semanal.py
index 43960d9721012..d18cc4298fed0 100644
--- a/mypy/semanal.py
+++ b/mypy/semanal.py
@@ -5084,14 +5084,14 @@ def translate_dict_call(self, call: CallExpr) -> DictExpr | None:
 
         For other variants of dict(...), return None.
         """
-        if not all(kind == ARG_NAMED for kind in call.arg_kinds):
+        if not all(kind in (ARG_NAMED, ARG_STAR2) for kind in call.arg_kinds):
             # Must still accept those args.
             for a in call.args:
                 a.accept(self)
             return None
         expr = DictExpr(
             [
-                (StrExpr(cast(str, key)), value)  # since they are all ARG_NAMED
+                (StrExpr(key) if key is not None else None, value)
                 for key, value in zip(call.arg_names, call.args)
             ]
         )
diff --git a/mypy/subtypes.py b/mypy/subtypes.py
index a3b28a3e24deb..c9de56edfa36b 100644
--- a/mypy/subtypes.py
+++ b/mypy/subtypes.py
@@ -694,7 +694,9 @@ def visit_callable_type(self, left: CallableType) -> bool:
                 right,
                 is_compat=self._is_subtype,
                 ignore_pos_arg_names=self.subtype_context.ignore_pos_arg_names,
-                strict_concatenate=self.options.strict_concatenate if self.options else True,
+                strict_concatenate=(self.options.extra_checks or self.options.strict_concatenate)
+                if self.options
+                else True,
             )
         elif isinstance(right, Overloaded):
             return all(self._is_subtype(left, item) for item in right.items)
@@ -858,7 +860,11 @@ def visit_overloaded(self, left: Overloaded) -> bool:
                     else:
                         # If this one overlaps with the supertype in any way, but it wasn't
                         # an exact match, then it's a potential error.
-                        strict_concat = self.options.strict_concatenate if self.options else True
+                        strict_concat = (
+                            (self.options.extra_checks or self.options.strict_concatenate)
+                            if self.options
+                            else True
+                        )
                         if left_index not in matched_overloads and (
                             is_callable_compatible(
                                 left_item,
diff --git a/mypy/types.py b/mypy/types.py
index 33673b58f7758..131383790ec8c 100644
--- a/mypy/types.py
+++ b/mypy/types.py
@@ -2437,6 +2437,7 @@ def copy_modified(
         *,
         fallback: Instance | None = None,
         item_types: list[Type] | None = None,
+        item_names: list[str] | None = None,
         required_keys: set[str] | None = None,
     ) -> TypedDictType:
         if fallback is None:
@@ -2447,6 +2448,9 @@ def copy_modified(
             items = dict(zip(self.items, item_types))
         if required_keys is None:
             required_keys = self.required_keys
+        if item_names is not None:
+            items = {k: v for (k, v) in items.items() if k in item_names}
+            required_keys &= set(item_names)
         return TypedDictType(items, required_keys, fallback, self.line, self.column)
 
     def create_anonymous_fallback(self) -> Instance:
diff --git a/test-data/unit/check-parameter-specification.test b/test-data/unit/check-parameter-specification.test
index cafcaca0a14ce..bebbbf4b16767 100644
--- a/test-data/unit/check-parameter-specification.test
+++ b/test-data/unit/check-parameter-specification.test
@@ -570,7 +570,7 @@ reveal_type(f(n))  # N: Revealed type is "def (builtins.int, builtins.bytes) ->
 [builtins fixtures/paramspec.pyi]
 
 [case testParamSpecConcatenateNamedArgs]
-# flags: --python-version 3.8 --strict-concatenate
+# flags: --python-version 3.8 --extra-checks
 # this is one noticeable deviation from PEP but I believe it is for the better
 from typing_extensions import ParamSpec, Concatenate
 from typing import Callable, TypeVar
diff --git a/test-data/unit/check-typeddict.test b/test-data/unit/check-typeddict.test
index fc487d2d553dd..4d2d648485153 100644
--- a/test-data/unit/check-typeddict.test
+++ b/test-data/unit/check-typeddict.test
@@ -2885,3 +2885,364 @@ d: A
 d['']  # E: TypedDict "A" has no key ""
 [builtins fixtures/dict.pyi]
 [typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictFlexibleUpdate]
+from mypy_extensions import TypedDict
+
+A = TypedDict("A", {"foo": int, "bar": int})
+B = TypedDict("B", {"foo": int})
+
+a = A({"foo": 1, "bar": 2})
+b = B({"foo": 2})
+a.update({"foo": 2})
+a.update(b)
+a.update(a)
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictStrictUpdate]
+# flags: --extra-checks
+from mypy_extensions import TypedDict
+
+A = TypedDict("A", {"foo": int, "bar": int})
+B = TypedDict("B", {"foo": int})
+
+a = A({"foo": 1, "bar": 2})
+b = B({"foo": 2})
+a.update({"foo": 2})  # OK
+a.update(b)  # E: Argument 1 to "update" of "TypedDict" has incompatible type "B"; expected "TypedDict({'foo': int, 'bar'?: int})"
+a.update(a)  # OK
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictFlexibleUpdateUnion]
+from typing import Union
+from mypy_extensions import TypedDict
+
+A = TypedDict("A", {"foo": int, "bar": int})
+B = TypedDict("B", {"foo": int})
+C = TypedDict("C", {"bar": int})
+
+a = A({"foo": 1, "bar": 2})
+u: Union[B, C]
+a.update(u)
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictFlexibleUpdateUnionExtra]
+from typing import Union
+from mypy_extensions import TypedDict
+
+A = TypedDict("A", {"foo": int, "bar": int})
+B = TypedDict("B", {"foo": int, "extra": int})
+C = TypedDict("C", {"bar": int, "extra": int})
+
+a = A({"foo": 1, "bar": 2})
+u: Union[B, C]
+a.update(u)
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictFlexibleUpdateUnionStrict]
+# flags: --extra-checks
+from typing import Union, NotRequired
+from mypy_extensions import TypedDict
+
+A = TypedDict("A", {"foo": int, "bar": int})
+A1 = TypedDict("A1", {"foo": int, "bar": NotRequired[int]})
+A2 = TypedDict("A2", {"foo": NotRequired[int], "bar": int})
+B = TypedDict("B", {"foo": int})
+C = TypedDict("C", {"bar": int})
+
+a = A({"foo": 1, "bar": 2})
+u: Union[B, C]
+a.update(u)  # E: Argument 1 to "update" of "TypedDict" has incompatible type "Union[B, C]"; expected "Union[TypedDict({'foo': int, 'bar'?: int}), TypedDict({'foo'?: int, 'bar': int})]"
+u2: Union[A1, A2]
+a.update(u2)  # OK
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictUnpackSame]
+# flags: --extra-checks
+from typing import TypedDict
+
+class Foo(TypedDict):
+    a: int
+    b: int
+
+foo1: Foo = {"a": 1, "b": 1}
+foo2: Foo = {**foo1, "b": 2}
+foo3 = Foo(**foo1, b=2)
+foo4 = Foo({**foo1, "b": 2})
+foo5 = Foo(dict(**foo1, b=2))
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictUnpackCompatible]
+# flags: --extra-checks
+from typing import TypedDict
+
+class Foo(TypedDict):
+    a: int
+
+class Bar(TypedDict):
+    a: int
+    b: int
+
+foo: Foo = {"a": 1}
+bar: Bar = {**foo, "b": 2}
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictUnpackIncompatible]
+from typing import TypedDict
+
+class Foo(TypedDict):
+    a: int
+    b: str
+
+class Bar(TypedDict):
+    a: int
+    b: int
+
+foo: Foo = {"a": 1, "b": "a"}
+bar1: Bar = {**foo, "b": 2}  # Incompatible item is overriden
+bar2: Bar = {**foo, "a": 2}  # E: Incompatible types (expression has type "str", TypedDict item "b" has type "int")
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictUnpackNotRequiredKeyIncompatible]
+from typing import TypedDict, NotRequired
+
+class Foo(TypedDict):
+    a: NotRequired[str]
+
+class Bar(TypedDict):
+    a: NotRequired[int]
+
+foo: Foo = {}
+bar: Bar = {**foo}  # E: Incompatible types (expression has type "str", TypedDict item "a" has type "int")
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+
+[case testTypedDictUnpackMissingOrExtraKey]
+from typing import TypedDict
+
+class Foo(TypedDict):
+    a: int
+
+class Bar(TypedDict):
+    a: int
+    b: int
+
+foo1: Foo = {"a": 1}
+bar1: Bar = {"a": 1, "b": 1}
+foo2: Foo = {**bar1}  # E: Extra key "b" for TypedDict "Foo"
+bar2: Bar = {**foo1}  # E: Missing key "b" for TypedDict "Bar"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictUnpackNotRequiredKeyExtra]
+from typing import TypedDict, NotRequired
+
+class Foo(TypedDict):
+    a: int
+
+class Bar(TypedDict):
+    a: int
+    b: NotRequired[int]
+
+foo1: Foo = {"a": 1}
+bar1: Bar = {"a": 1}
+foo2: Foo = {**bar1}  # E: Extra key "b" for TypedDict "Foo"
+bar2: Bar = {**foo1}
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictUnpackRequiredKeyMissing]
+from typing import TypedDict, NotRequired
+
+class Foo(TypedDict):
+    a: NotRequired[int]
+
+class Bar(TypedDict):
+    a: int
+
+foo: Foo = {"a": 1}
+bar: Bar = {**foo}  # E: Missing key "a" for TypedDict "Bar"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictUnpackMultiple]
+# flags: --extra-checks
+from typing import TypedDict
+
+class Foo(TypedDict):
+    a: int
+
+class Bar(TypedDict):
+    b: int
+
+class Baz(TypedDict):
+    a: int
+    b: int
+    c: int
+
+foo: Foo = {"a": 1}
+bar: Bar = {"b": 1}
+baz: Baz = {**foo, **bar, "c": 1}
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictUnpackNested]
+from typing import TypedDict
+
+class Foo(TypedDict):
+    a: int
+    b: int
+
+class Bar(TypedDict):
+    c: Foo
+    d: int
+
+foo: Foo = {"a": 1, "b": 1}
+bar: Bar = {"c": foo, "d": 1}
+bar2: Bar = {**bar, "c": {**bar["c"], "b": 2}, "d": 2}
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictUnpackNestedError]
+from typing import TypedDict
+
+class Foo(TypedDict):
+    a: int
+    b: int
+
+class Bar(TypedDict):
+    c: Foo
+    d: int
+
+foo: Foo = {"a": 1, "b": 1}
+bar: Bar = {"c": foo, "d": 1}
+bar2: Bar = {**bar, "c": {**bar["c"], "b": "wrong"}, "d": 2}  # E: Incompatible types (expression has type "str", TypedDict item "b" has type "int")
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictUnpackOverrideRequired]
+from mypy_extensions import TypedDict
+
+Details = TypedDict('Details', {'first_name': str, 'last_name': str})
+DetailsSubset = TypedDict('DetailsSubset', {'first_name': str, 'last_name': str}, total=False)
+defaults: Details = {'first_name': 'John', 'last_name': 'Luther'}
+
+def generate(data: DetailsSubset) -> Details:
+    return {**defaults, **data}  # OK
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictUnpackUntypedDict]
+from typing import Any, Dict, TypedDict
+
+class Bar(TypedDict):
+    pass
+
+foo: Dict[str, Any] = {}
+bar: Bar = {**foo}  # E: Unsupported type "Dict[str, Any]" for ** expansion in TypedDict
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictUnpackIntoUnion]
+from typing import TypedDict, Union
+
+class Foo(TypedDict):
+    a: int
+
+class Bar(TypedDict):
+    b: int
+
+foo: Foo = {'a': 1}
+foo_or_bar: Union[Foo, Bar] = {**foo}
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictUnpackFromUnion]
+from typing import TypedDict, Union
+
+class Foo(TypedDict):
+    a: int
+    b: int
+
+class Bar(TypedDict):
+    b: int
+
+foo_or_bar: Union[Foo, Bar] = {'b': 1}
+foo: Bar = {**foo_or_bar}  # E: Extra key "a" for TypedDict "Bar"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictUnpackUnionRequiredMissing]
+from typing import TypedDict, NotRequired, Union
+
+class Foo(TypedDict):
+    a: int
+    b: int
+
+class Bar(TypedDict):
+    a: int
+    b: NotRequired[int]
+
+foo_or_bar: Union[Foo, Bar] = {"a": 1}
+foo: Foo = {**foo_or_bar}  # E: Missing key "b" for TypedDict "Foo"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictUnpackInference]
+from typing import TypedDict, Generic, TypeVar
+
+class Foo(TypedDict):
+    a: int
+    b: str
+
+T = TypeVar("T")
+class TD(TypedDict, Generic[T]):
+    a: T
+    b: str
+
+foo: Foo
+bar = TD(**foo)
+reveal_type(bar)  # N: Revealed type is "TypedDict('__main__.TD', {'a': builtins.int, 'b': builtins.str})"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictUnpackStrictMode]
+# flags: --extra-checks
+from typing import TypedDict, NotRequired
+
+class Foo(TypedDict):
+    a: int
+
+class Bar(TypedDict):
+    a: int
+    b: NotRequired[int]
+
+foo: Foo
+bar: Bar = {**foo}  # E: Non-required key "b" not explicitly found in any ** item
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]
+
+[case testTypedDictUnpackAny]
+from typing import Any, TypedDict, NotRequired, Dict, Union
+
+class Foo(TypedDict):
+    a: int
+    b: NotRequired[int]
+
+x: Any
+y: Dict[Any, Any]
+z: Union[Any, Dict[Any, Any]]
+t1: Foo = {**x}  # E: Missing key "a" for TypedDict "Foo"
+t2: Foo = {**y}  # E: Missing key "a" for TypedDict "Foo"
+t3: Foo = {**z}  # E: Missing key "a" for TypedDict "Foo"
+[builtins fixtures/dict.pyi]
+[typing fixtures/typing-typeddict.pyi]

From 4d94271b37dd2912e3030c5c5d71fd22099e0eb2 Mon Sep 17 00:00:00 2001
From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
Date: Tue, 27 Jun 2023 14:48:39 +0200
Subject: [PATCH 079/129] Fix check-manifest action (#15531)

Fix sdist and python wheel build.
https://github.com/mgedmin/check-manifest

https://github.com/mypyc/mypy_mypyc-wheels/actions/runs/5384036273/jobs/9771489841#step:5:32
---
 pyproject.toml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/pyproject.toml b/pyproject.toml
index fc70d4279681d..399168663bed6 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -76,3 +76,6 @@ extend-exclude = [
   # typeshed has its own .pyi-specific configuration
   "mypy/typeshed/*",
 ]
+
+[tool.check-manifest]
+ignore = ["**/.readthedocs.yaml"]

From 4012c50382641aa4a15fcb7155f281469bc7a5fa Mon Sep 17 00:00:00 2001
From: Alex Waygood <Alex.Waygood@Gmail.com>
Date: Wed, 28 Jun 2023 02:03:57 +0100
Subject: [PATCH 080/129] Improve ruff config (#15516)

---
 .github/workflows/test.yml |  2 +-
 .pre-commit-config.yaml    |  5 +----
 CONTRIBUTING.md            | 11 ++---------
 README.md                  |  2 +-
 mypy/copytype.py           |  2 +-
 pyproject.toml             | 30 +++++++++++++++---------------
 test-requirements.txt      |  1 -
 tox.ini                    |  1 +
 8 files changed, 22 insertions(+), 32 deletions(-)

diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 6fc8fb11c6f43..5bd20f2773c59 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -96,7 +96,7 @@ jobs:
           # We also run these checks with pre-commit in CI,
           # but it's useful to run them with tox too,
           # to ensure the tox env works as expected
-        - name: Formatting with Black + isort and code style with ruff
+        - name: Formatting and code style with Black + ruff
           python: '3.10'
           arch: x64
           os: ubuntu-latest
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index cbb3672bd9865..1ad273ce55844 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -9,11 +9,8 @@ repos:
     rev: 23.3.0  # must match test-requirements.txt
     hooks:
       - id: black
-  - repo: https://github.com/pycqa/isort
-    rev: 5.12.0  # must match test-requirements.txt
-    hooks:
-      - id: isort
   - repo: https://github.com/astral-sh/ruff-pre-commit
     rev: v0.0.272  # must match test-requirements.txt
     hooks:
       - id: ruff
+        args: [--exit-non-zero-on-fix]
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 99ba2f8c9a766..82e55f437e872 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -88,11 +88,8 @@ pytest -n0 -k 'test_name'
 # Run all test cases in the "test-data/unit/check-dataclasses.test" file
 pytest mypy/test/testcheck.py::TypeCheckSuite::check-dataclasses.test
 
-# Run the linter
-ruff .
-
-# Run formatters
-black . && isort .
+# Run the formatters and linters
+python runtests.py lint
 ```
 
 For an in-depth guide on running and writing tests,
@@ -154,10 +151,6 @@ advice about good pull requests for open-source projects applies; we
 have [our own writeup](https://github.com/python/mypy/wiki/Good-Pull-Request)
 of this advice.
 
-We are using `black` and `isort` to enforce a consistent coding style.
-Run `black . && isort .` before your commits, otherwise you would receive
-a CI failure.
-
 Also, do not squash your commits after you have submitted a pull request, as this
 erases context during review. We will squash commits when the pull request is merged.
 
diff --git a/README.md b/README.md
index 164957b1491a1..8b1ebbc0f2cba 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,7 @@ Mypy: Static Typing for Python
 [![Chat at https://gitter.im/python/typing](https://badges.gitter.im/python/typing.svg)](https://gitter.im/python/typing?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
-[![Imports: isort](https://img.shields.io/badge/%20imports-isort-%231674b1?style=flat&labelColor=ef8336)](https://pycqa.github.io/isort/)
+[![Linting: Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
 
 Got a question?
 ---------------
diff --git a/mypy/copytype.py b/mypy/copytype.py
index 0b63c8e07ae88..4ca381c4a8c40 100644
--- a/mypy/copytype.py
+++ b/mypy/copytype.py
@@ -28,7 +28,7 @@
 )
 
 # type_visitor needs to be imported after types
-from mypy.type_visitor import TypeVisitor  # isort: skip
+from mypy.type_visitor import TypeVisitor  # ruff: isort: skip
 
 
 def copy_type(t: ProperType) -> ProperType:
diff --git a/pyproject.toml b/pyproject.toml
index 399168663bed6..22e28f8f6f688 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -27,29 +27,18 @@ force-exclude = '''
 ^/test-data
 '''
 
-[tool.isort]
-py_version = 37
-profile = "black"
-line_length = 99
-combine_as_imports = true
-skip_gitignore = true
-extra_standard_library = ["typing_extensions"]
-skip_glob = [
-    "mypy/typeshed/*",
-    "mypyc/test-data/*",
-    "test-data/*",
-]
-
 [tool.ruff]
 line-length = 99
 target-version = "py37"
+fix = true
 
 select = [
-  "E",       # pycoderstyle (error)
+  "E",       # pycodestyle (error)
   "F",       # pyflakes
   "B",       # flake8-bugbear
+  "I",       # isort
   "RUF100",  # Unused noqa comments
-  "PGH004"  # blanket noqa comments
+  "PGH004"   # blanket noqa comments
 ]
 
 ignore = [
@@ -64,6 +53,13 @@ ignore = [
   "E741",  # Ambiguous variable name
 ]
 
+unfixable = [
+    "F841",  # unused variable. ruff keeps the call, but mostly we want to get rid of it all
+    "F601",  # automatic fix might obscure issue
+    "F602",  # automatic fix might obscure issue
+    "B018",  # automatic fix might obscure issue
+]
+
 extend-exclude = [
   "@*",
   # Sphinx configuration is irrelevant
@@ -77,5 +73,9 @@ extend-exclude = [
   "mypy/typeshed/*",
 ]
 
+[tool.ruff.isort]
+combine-as-imports = true
+extra-standard-library = ["typing_extensions"]
+
 [tool.check-manifest]
 ignore = ["**/.readthedocs.yaml"]
diff --git a/test-requirements.txt b/test-requirements.txt
index f7d37058e544d..6b046e1469ebe 100644
--- a/test-requirements.txt
+++ b/test-requirements.txt
@@ -3,7 +3,6 @@
 attrs>=18.0
 black==23.3.0  # must match version in .pre-commit-config.yaml
 filelock>=3.3.0
-isort[colors]==5.12.0; python_version >= "3.8"   # must match version in .pre-commit-config.yaml
 lxml>=4.9.1; (python_version<'3.11' or sys_platform!='win32') and python_version<'3.12'
 pre-commit
 pre-commit-hooks==4.4.0
diff --git a/tox.ini b/tox.ini
index 2ddda8281beb0..b5314114570b5 100644
--- a/tox.ini
+++ b/tox.ini
@@ -43,6 +43,7 @@ commands =
 [testenv:lint]
 description = check the code style
 skip_install = true
+deps = pre-commit
 commands = pre-commit run --all-files --show-diff-on-failure
 
 [testenv:type]

From 310b914b6046830aafb0468f65464d75362991ab Mon Sep 17 00:00:00 2001
From: Ivan Levkivskyi <levkivskyi@gmail.com>
Date: Wed, 28 Jun 2023 11:17:39 +0100
Subject: [PATCH 081/129] Add missing docs for error codes (#15539)

I am adding these mostly to get rid of the allowlist in
`html_builder.py`, please feel free to tweak these docs, cc @JukkaL
@hauntsaninja @JelleZijlstra
---
 docs/source/error_code_list.rst  | 97 ++++++++++++++++++++++++++++++++
 docs/source/error_code_list2.rst | 26 +++++++++
 docs/source/html_builder.py      | 14 +----
 mypy/errorcodes.py               |  2 +-
 4 files changed, 125 insertions(+), 14 deletions(-)

diff --git a/docs/source/error_code_list.rst b/docs/source/error_code_list.rst
index 1654c5910f981..f935e025e589a 100644
--- a/docs/source/error_code_list.rst
+++ b/docs/source/error_code_list.rst
@@ -323,6 +323,38 @@ Example:
         else:
             raise ValueError('not defined for zero')
 
+.. _code-empty-body:
+
+Check that functions don't have empty bodies outside stubs [empty-body]
+-----------------------------------------------------------------------
+
+This error code is similar to the ``[return]`` code but is emitted specifically
+for functions and methods with empty bodies (if they are annotated with
+non-trivial return type). Such a distinction exists because in some contexts
+an empty body can be valid, for example for an abstract method or in a stub
+file. Also old versions of mypy used to unconditionally allow functions with
+empty bodies, so having a dedicated error code simplifies cross-version
+compatibility.
+
+Note that empty bodies are allowed for methods in *protocols*, and such methods
+are considered implicitly abstract:
+
+.. code-block:: python
+
+   from abc import abstractmethod
+   from typing import Protocol
+
+   class RegularABC:
+       @abstractmethod
+       def foo(self) -> int:
+           pass  # OK
+       def bar(self) -> int:
+           pass  # Error: Missing return statement  [empty-body]
+
+   class Proto(Protocol):
+       def bar(self) -> int:
+           pass  # OK
+
 .. _code-return-value:
 
 Check that return value is compatible [return-value]
@@ -947,6 +979,28 @@ otherwise unused variable:
 
        _ = f()  # No error
 
+.. _code-top-level-await:
+
+Warn about top level await expressions [top-level-await]
+--------------------------------------------------------
+
+This error code is separate from the general ``[syntax]`` errors, because in
+some environments (e.g. IPython) a top level ``await`` is allowed. In such
+environments a user may want to use ``--disable-error-code=top-level-await``,
+that allows to still have errors for other improper uses of ``await``, for
+example:
+
+.. code-block:: python
+
+   async def f() -> None:
+       ...
+
+   top = await f()  # Error: "await" outside function  [top-level-await]
+
+   def g() -> None:
+       # This is a blocker error and cannot be silenced.
+       await f()  # Error: "await" outside coroutine ("async def")
+
 .. _code-assert-type:
 
 Check types in assert_type [assert-type]
@@ -978,6 +1032,27 @@ Functions will always evaluate to true in boolean contexts.
     if f:  # Error: Function "Callable[[], Any]" could always be true in boolean context  [truthy-function]
         pass
 
+.. _code-str-format:
+
+Check that string formatting/interpolation is type-safe [str-format]
+--------------------------------------------------------------------
+
+Mypy will check that f-strings, ``str.format()`` calls, and ``%`` interpolations
+are valid (when corresponding template is a literal string). This includes
+checking number and types of replacements, for example:
+
+.. code-block:: python
+
+    # Error: Cannot find replacement for positional format specifier 1 [str-format]
+    "{} and {}".format("spam")
+    "{} and {}".format("spam", "eggs")  # OK
+    # Error: Not all arguments converted during string formatting [str-format]
+    "{} and {}".format("spam", "eggs", "cheese")
+
+    # Error: Incompatible types in string interpolation
+    # (expression has type "float", placeholder has type "int") [str-format]
+    "{:d}".format(3.14)
+
 .. _code-str-bytes-safe:
 
 Check for implicit bytes coercions [str-bytes-safe]
@@ -998,6 +1073,28 @@ Warn about cases where a bytes object may be converted to a string in an unexpec
     print(f"The alphabet starts with {b!r}")  # The alphabet starts with b'abc'
     print(f"The alphabet starts with {b.decode('utf-8')}")  # The alphabet starts with abc
 
+.. _code-annotation-unchecked:
+
+Notify about an annotation in an unchecked function [annotation-unchecked]
+--------------------------------------------------------------------------
+
+Sometimes a user may accidentally omit an annotation for a function, and mypy
+will not check the body of this function (unless one uses
+:option:`--check-untyped-defs <mypy --check-untyped-defs>` or
+:option:`--disallow-untyped-defs <mypy --disallow-untyped-defs>`). To avoid
+such situations go unnoticed, mypy will show a note, if there are any type
+annotations in an unchecked function:
+
+.. code-block:: python
+
+    def test_assignment():  # "-> None" return annotation is missing
+        # Note: By default the bodies of untyped functions are not checked,
+        # consider using --check-untyped-defs [annotation-unchecked]
+        x: int = "no way"
+
+Note that mypy will still exit with return code ``0``, since such behaviour is
+specified by :pep:`484`.
+
 .. _code-syntax:
 
 Report syntax errors [syntax]
diff --git a/docs/source/error_code_list2.rst b/docs/source/error_code_list2.rst
index 11f463f93018e..e1d47f7cbec06 100644
--- a/docs/source/error_code_list2.rst
+++ b/docs/source/error_code_list2.rst
@@ -255,6 +255,32 @@ mypy generates an error if it thinks that an expression is redundant.
         [i for i in range(x) if isinstance(i, int)]
 
 
+.. _code-possibly-undefined:
+
+Warn about variables that are defined only in some execution paths [possibly-undefined]
+---------------------------------------------------------------------------------------
+
+If you use :option:`--enable-error-code possibly-undefined <mypy --enable-error-code>`,
+mypy generates an error if it cannot verify that a variable will be defined in
+all execution paths. This includes situations when a variable definition
+appears in a loop, in a conditional branch, in an except handler, etc. For
+example:
+
+.. code-block:: python
+
+    # Use "mypy --enable-error-code possibly-undefined ..."
+
+    from typing import Iterable
+
+    def test(values: Iterable[int], flag: bool) -> None:
+        if flag:
+            a = 1
+        z = a + 1  # Error: Name "a" may be undefined [possibly-undefined]
+
+        for v in values:
+            b = v
+        z = b + 1  # Error: Name "b" may be undefined [possibly-undefined]
+
 .. _code-truthy-bool:
 
 Check that expression is not implicitly true in boolean context [truthy-bool]
diff --git a/docs/source/html_builder.py b/docs/source/html_builder.py
index 405b80ac53d22..3064833b5631f 100644
--- a/docs/source/html_builder.py
+++ b/docs/source/html_builder.py
@@ -23,19 +23,7 @@ def write_doc(self, docname: str, doctree: document) -> None:
     def _verify_error_codes(self) -> None:
         from mypy.errorcodes import error_codes
 
-        known_missing = {
-            # TODO: fix these before next release
-            "annotation-unchecked",
-            "empty-body",
-            "possibly-undefined",
-            "str-format",
-            "top-level-await",
-        }
-        missing_error_codes = {
-            c
-            for c in error_codes
-            if f"code-{c}" not in self._ref_to_doc and c not in known_missing
-        }
+        missing_error_codes = {c for c in error_codes if f"code-{c}" not in self._ref_to_doc}
         if missing_error_codes:
             raise ValueError(
                 f"Some error codes are not documented: {', '.join(sorted(missing_error_codes))}"
diff --git a/mypy/errorcodes.py b/mypy/errorcodes.py
index e87b04b6f4738..b9448f3d5af92 100644
--- a/mypy/errorcodes.py
+++ b/mypy/errorcodes.py
@@ -144,7 +144,7 @@ def __hash__(self) -> int:
     "safe-super", "Warn about calls to abstract methods with empty/trivial bodies", "General"
 )
 TOP_LEVEL_AWAIT: Final = ErrorCode(
-    "top-level-await", "Warn about top level await experessions", "General"
+    "top-level-await", "Warn about top level await expressions", "General"
 )
 
 # These error codes aren't enabled by default.

From fca4cae2537e2aabba2bc5393ef81f2d80cdb5ae Mon Sep 17 00:00:00 2001
From: Ivan Levkivskyi <levkivskyi@gmail.com>
Date: Wed, 28 Jun 2023 21:57:11 +0100
Subject: [PATCH 082/129] Add option to show links to error code docs (once per
 code) (#15449)

Fixes #7186

We can probably add some kind of redirect from mypy-lang.org, but I
think RTD link is already OK. This PR will need to wait until next
release, unless we want to use `/latest` in the link.
---
 mypy/errors.py                  | 78 +++++++++++++++++++++++++++++++++
 mypy/main.py                    |  6 +++
 mypy/options.py                 |  1 +
 mypy_self_check.ini             |  1 +
 test-data/unit/check-flags.test | 15 +++++++
 5 files changed, 101 insertions(+)

diff --git a/mypy/errors.py b/mypy/errors.py
index 0e61f5ecf0cd6..6739d30f16a4b 100644
--- a/mypy/errors.py
+++ b/mypy/errors.py
@@ -20,8 +20,27 @@
 # Show error codes for some note-level messages (these usually appear alone
 # and not as a comment for a previous error-level message).
 SHOW_NOTE_CODES: Final = {codes.ANNOTATION_UNCHECKED}
+
+# Do not add notes with links to error code docs to errors with these codes.
+# We can tweak this set as we get more experience about what is helpful and what is not.
+HIDE_LINK_CODES: Final = {
+    # This is a generic error code, so it has no useful docs
+    codes.MISC,
+    # These are trivial and have some custom notes (e.g. for list being invariant)
+    codes.ASSIGNMENT,
+    codes.ARG_TYPE,
+    codes.RETURN_VALUE,
+    # Undefined name/attribute errors are self-explanatory
+    codes.ATTR_DEFINED,
+    codes.NAME_DEFINED,
+    # Overrides have a custom link to docs
+    codes.OVERRIDE,
+}
+
 allowed_duplicates: Final = ["@overload", "Got:", "Expected:"]
 
+BASE_RTD_URL: Final = "https://mypy.rtfd.io/en/stable/_refs.html#code"
+
 # Keep track of the original error code when the error code of a message is changed.
 # This is used to give notes about out-of-date "type: ignore" comments.
 original_error_codes: Final = {codes.LITERAL_REQ: codes.MISC, codes.TYPE_ABSTRACT: codes.MISC}
@@ -107,6 +126,7 @@ def __init__(
         allow_dups: bool,
         origin: tuple[str, Iterable[int]] | None = None,
         target: str | None = None,
+        priority: int = 0,
     ) -> None:
         self.import_ctx = import_ctx
         self.file = file
@@ -125,6 +145,7 @@ def __init__(
         self.allow_dups = allow_dups
         self.origin = origin or (file, [line])
         self.target = target
+        self.priority = priority
 
 
 # Type used internally to represent errors:
@@ -530,6 +551,35 @@ def add_error_info(self, info: ErrorInfo) -> None:
                 allow_dups=False,
             )
             self._add_error_info(file, note)
+        if (
+            self.options.show_error_code_links
+            and not self.options.hide_error_codes
+            and info.code is not None
+            and info.code not in HIDE_LINK_CODES
+        ):
+            message = f"See {BASE_RTD_URL}-{info.code.code} for more info"
+            if message in self.only_once_messages:
+                return
+            self.only_once_messages.add(message)
+            info = ErrorInfo(
+                import_ctx=info.import_ctx,
+                file=info.file,
+                module=info.module,
+                typ=info.type,
+                function_or_member=info.function_or_member,
+                line=info.line,
+                column=info.column,
+                end_line=info.end_line,
+                end_column=info.end_column,
+                severity="note",
+                message=message,
+                code=info.code,
+                blocker=False,
+                only_once=True,
+                allow_dups=False,
+                priority=20,
+            )
+            self._add_error_info(file, info)
 
     def has_many_errors(self) -> bool:
         if self.options.many_errors_threshold < 0:
@@ -1041,6 +1091,34 @@ def sort_messages(self, errors: list[ErrorInfo]) -> list[ErrorInfo]:
 
             # Sort the errors specific to a file according to line number and column.
             a = sorted(errors[i0:i], key=lambda x: (x.line, x.column))
+            a = self.sort_within_context(a)
+            result.extend(a)
+        return result
+
+    def sort_within_context(self, errors: list[ErrorInfo]) -> list[ErrorInfo]:
+        """For the same location decide which messages to show first/last.
+
+        Currently, we only compare within the same error code, to decide the
+        order of various additional notes.
+        """
+        result = []
+        i = 0
+        while i < len(errors):
+            i0 = i
+            # Find neighbouring errors with the same position and error code.
+            while (
+                i + 1 < len(errors)
+                and errors[i + 1].line == errors[i].line
+                and errors[i + 1].column == errors[i].column
+                and errors[i + 1].end_line == errors[i].end_line
+                and errors[i + 1].end_column == errors[i].end_column
+                and errors[i + 1].code == errors[i].code
+            ):
+                i += 1
+            i += 1
+
+            # Sort the messages specific to a given error by priority.
+            a = sorted(errors[i0:i], key=lambda x: x.priority)
             result.extend(a)
         return result
 
diff --git a/mypy/main.py b/mypy/main.py
index 22ff3e32a718a..516bb1ee9b540 100644
--- a/mypy/main.py
+++ b/mypy/main.py
@@ -887,6 +887,12 @@ def add_invertible_flag(
         help="Hide error codes in error messages",
         group=error_group,
     )
+    add_invertible_flag(
+        "--show-error-code-links",
+        default=False,
+        help="Show links to error code documentation",
+        group=error_group,
+    )
     add_invertible_flag(
         "--pretty",
         default=False,
diff --git a/mypy/options.py b/mypy/options.py
index e1d731c1124c5..daa666dc76381 100644
--- a/mypy/options.py
+++ b/mypy/options.py
@@ -313,6 +313,7 @@ def __init__(self) -> None:
         self.show_column_numbers: bool = False
         self.show_error_end: bool = False
         self.hide_error_codes = False
+        self.show_error_code_links = False
         # Use soft word wrap and show trimmed source snippets with error location markers.
         self.pretty = False
         self.dump_graph = False
diff --git a/mypy_self_check.ini b/mypy_self_check.ini
index d20fcd60a9cb4..62083d1446214 100644
--- a/mypy_self_check.ini
+++ b/mypy_self_check.ini
@@ -9,6 +9,7 @@ plugins = misc/proper_plugin.py
 python_version = 3.7
 exclude = mypy/typeshed/|mypyc/test-data/|mypyc/lib-rt/
 enable_error_code = ignore-without-code,redundant-expr
+show_error_code_links = True
 
 [mypy-mypy.visitor]
 # See docstring for NodeVisitor for motivation.
diff --git a/test-data/unit/check-flags.test b/test-data/unit/check-flags.test
index 6ec0849146c04..c356028f66204 100644
--- a/test-data/unit/check-flags.test
+++ b/test-data/unit/check-flags.test
@@ -2195,3 +2195,18 @@ cb(lambda x: a)  # OK
 
 fn = lambda x: a
 cb(fn)
+
+[case testShowErrorCodeLinks]
+# flags: --show-error-codes --show-error-code-links
+
+x: int = ""  # E: Incompatible types in assignment (expression has type "str", variable has type "int")  [assignment]
+list(1)  # E: No overload variant of "list" matches argument type "int"  [call-overload] \
+         # N: Possible overload variants: \
+         # N:     def [T] __init__(self) -> List[T] \
+         # N:     def [T] __init__(self, x: Iterable[T]) -> List[T] \
+         # N: See https://mypy.rtfd.io/en/stable/_refs.html#code-call-overload for more info
+list(2)  # E: No overload variant of "list" matches argument type "int"  [call-overload] \
+         # N: Possible overload variants: \
+         # N:     def [T] __init__(self) -> List[T] \
+         # N:     def [T] __init__(self, x: Iterable[T]) -> List[T]
+[builtins fixtures/list.pyi]

From 9a4a5aa77a303c2e56e9dc9bd9327974bf777894 Mon Sep 17 00:00:00 2001
From: Richard Si <sichard26@gmail.com>
Date: Wed, 28 Jun 2023 18:25:43 -0400
Subject: [PATCH 083/129] Process NamedTuple decorators in semantic analyzer
 (#15513)

---
 mypy/semanal.py                        |  4 ++++
 mypyc/test-data/run-tuples.test        |  6 ++++++
 test-data/unit/semanal-namedtuple.test | 20 ++++++++++++++++++++
 3 files changed, 30 insertions(+)

diff --git a/mypy/semanal.py b/mypy/semanal.py
index d18cc4298fed0..1eb14e499e4d8 100644
--- a/mypy/semanal.py
+++ b/mypy/semanal.py
@@ -1744,6 +1744,10 @@ def analyze_namedtuple_classdef(
                 self.setup_type_vars(defn, tvar_defs)
                 self.setup_alias_type_vars(defn)
                 with self.scope.class_scope(defn.info):
+                    for deco in defn.decorators:
+                        deco.accept(self)
+                        if isinstance(deco, RefExpr) and deco.fullname in FINAL_DECORATOR_NAMES:
+                            info.is_final = True
                     with self.named_tuple_analyzer.save_namedtuple_body(info):
                         self.analyze_class_body_common(defn)
             return True
diff --git a/mypyc/test-data/run-tuples.test b/mypyc/test-data/run-tuples.test
index f6c92b9c720fa..0851c15e57fdb 100644
--- a/mypyc/test-data/run-tuples.test
+++ b/mypyc/test-data/run-tuples.test
@@ -98,6 +98,7 @@ assert f(Sub(3, 2)) == 3
 -- Ref: https://github.com/mypyc/mypyc/issues/924
 [case testNamedTupleClassSyntax]
 from typing import Dict, List, NamedTuple, Optional, Tuple, Union
+from typing_extensions import final
 
 class FuncIR: pass
 
@@ -121,6 +122,11 @@ class Record(NamedTuple):
 # Ref: https://github.com/mypyc/mypyc/issues/938
 class ClassIR: pass
 
+# Ref: https://github.com/mypyc/mypyc/issues/927
+@final
+class Inextensible(NamedTuple):
+    x: int
+
 [file driver.py]
 from typing import ForwardRef, Optional
 from native import ClassIR, FuncIR, Record
diff --git a/test-data/unit/semanal-namedtuple.test b/test-data/unit/semanal-namedtuple.test
index df1d5679c892c..f396f799028fe 100644
--- a/test-data/unit/semanal-namedtuple.test
+++ b/test-data/unit/semanal-namedtuple.test
@@ -225,3 +225,23 @@ class B(A): pass
 [out]
 main:2: error: Unsupported dynamic base class "NamedTuple"
 main:2: error: Name "NamedTuple" is not defined
+
+[case testNamedTupleWithDecorator]
+from typing import final, NamedTuple
+
+@final
+class A(NamedTuple("N", [("x", int)])):
+    pass
+[builtins fixtures/tuple.pyi]
+[out]
+MypyFile:1(
+  ImportFrom:1(typing, [final, NamedTuple])
+  ClassDef:4(
+    A
+    TupleType(
+      Tuple[builtins.int, fallback=__main__.N@4])
+    Decorators(
+      NameExpr(final [typing.final]))
+    BaseType(
+      __main__.N@4)
+    PassStmt:5()))

From 05c81d69b724afd20f501b6427aa3f740083a916 Mon Sep 17 00:00:00 2001
From: Jelle Zijlstra <jelle.zijlstra@gmail.com>
Date: Wed, 28 Jun 2023 17:53:59 -0700
Subject: [PATCH 084/129] Fix tests on 3.7 (#15543)

---
 mypyc/irbuild/classdef.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/mypyc/irbuild/classdef.py b/mypyc/irbuild/classdef.py
index 59b1c05a0ddbd..fcb2afba0939f 100644
--- a/mypyc/irbuild/classdef.py
+++ b/mypyc/irbuild/classdef.py
@@ -498,6 +498,9 @@ def populate_non_ext_bases(builder: IRBuilder, cdef: ClassDef) -> Value:
                 if builder.options.capi_version < (3, 8):
                     # TypedDict was added to typing in Python 3.8.
                     module = "typing_extensions"
+                    # It needs to be "_TypedDict" on typing_extensions 4.7.0+
+                    # and "TypedDict" otherwise.
+                    name = "_TypedDict"
             else:
                 # In Python 3.9 TypedDict is not a real type.
                 name = "_TypedDict"

From 66d03daf35bde2dcc8fdc746aa31b2f59dcba515 Mon Sep 17 00:00:00 2001
From: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
Date: Thu, 29 Jun 2023 00:40:24 -0700
Subject: [PATCH 085/129] Fix find occurrences flag (#15528)

---
 mypy/main.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/mypy/main.py b/mypy/main.py
index 516bb1ee9b540..9d95bb6cb1f62 100644
--- a/mypy/main.py
+++ b/mypy/main.py
@@ -1349,12 +1349,12 @@ def set_strict_flags() -> None:
 
     # Set build flags.
     if special_opts.find_occurrences:
-        state.find_occurrences = special_opts.find_occurrences.split(".")
-        assert state.find_occurrences is not None
-        if len(state.find_occurrences) < 2:
+        _find_occurrences = tuple(special_opts.find_occurrences.split("."))
+        if len(_find_occurrences) < 2:
             parser.error("Can only find occurrences of class members.")
-        if len(state.find_occurrences) != 2:
+        if len(_find_occurrences) != 2:
             parser.error("Can only find occurrences of non-nested class members.")
+        state.find_occurrences = _find_occurrences  # type: ignore[assignment]
 
     # Set reports.
     for flag, val in vars(special_opts).items():

From 06282b55613a5c36c29b8ba1aafb067ac475e047 Mon Sep 17 00:00:00 2001
From: Alex Waygood <Alex.Waygood@Gmail.com>
Date: Thu, 29 Jun 2023 19:41:20 +0100
Subject: [PATCH 086/129] Consolidate config in pyproject.toml (#15548)

There's no real need for us to have separate `setup.cfg` and
`pytest.ini` files these days
---
 pyproject.toml | 44 ++++++++++++++++++++++++++++++++++++++++++++
 pytest.ini     | 27 ---------------------------
 setup.cfg      | 16 ----------------
 3 files changed, 44 insertions(+), 43 deletions(-)
 delete mode 100644 pytest.ini
 delete mode 100644 setup.cfg

diff --git a/pyproject.toml b/pyproject.toml
index 22e28f8f6f688..0b14dd419d08c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -79,3 +79,47 @@ extra-standard-library = ["typing_extensions"]
 
 [tool.check-manifest]
 ignore = ["**/.readthedocs.yaml"]
+
+[tool.pytest.ini_options]
+minversion = "6.0.0"
+testpaths = ["mypy/test", "mypyc/test"]
+python_files = 'test*.py'
+
+# Where do the test cases come from?  We provide our own collection
+# logic by implementing `pytest_pycollect_makeitem` in mypy.test.data;
+# the test files import that module, and pytest sees the magic name
+# and invokes it at the relevant moment.  See
+# https://doc.pytest.org/en/latest/how-to/writing_plugins.html#collection-hooks
+
+# Both our plugin and unittest provide their own collection logic,
+# So we can disable the default python collector by giving it empty
+# patterns to search for.
+# Note that unittest requires that no "Test*" classes exist.
+python_classes = []
+python_functions = []
+
+# always run in parallel (requires pytest-xdist, see test-requirements.txt)
+# and enable strict mode: require all markers
+# to be defined and raise on invalid config values
+addopts = "-nauto --strict-markers --strict-config"
+
+# treat xpasses as test failures so they get converted to regular tests as soon as possible
+xfail_strict = true
+
+[tool.coverage.run]
+branch = true
+source = "mypy"
+parallel = true
+
+[tool.coverage.report]
+show_missing = true
+skip_covered = true
+omit = 'mypy/test/*'
+exclude_lines = [
+  '\#\s*pragma: no cover',
+  '^\s*raise AssertionError\b',
+  '^\s*raise NotImplementedError\b',
+  '^\s*return NotImplemented\b',
+  '^\s*raise$',
+  '''^if __name__ == ['"]__main__['"]:$''',
+]
diff --git a/pytest.ini b/pytest.ini
deleted file mode 100644
index a123b0f113283..0000000000000
--- a/pytest.ini
+++ /dev/null
@@ -1,27 +0,0 @@
-[pytest]
-minversion = 6.0.0
-
-testpaths = mypy/test mypyc/test
-
-python_files = test*.py
-
-# Where do the test cases come from?  We provide our own collection
-# logic by implementing `pytest_pycollect_makeitem` in mypy.test.data;
-# the test files import that module, and pytest sees the magic name
-# and invokes it at the relevant moment.  See
-# https://doc.pytest.org/en/latest/how-to/writing_plugins.html#collection-hooks
-
-# Both our plugin and unittest provide their own collection logic,
-# So we can disable the default python collector by giving it empty
-# patterns to search for.
-# Note that unittest requires that no "Test*" classes exist.
-python_classes =
-python_functions =
-
-# always run in parallel (requires pytest-xdist, see test-requirements.txt)
-# and enable strict mode: require all markers
-# to be defined and raise on invalid config values
-addopts = -nauto --strict-markers --strict-config
-
-# treat xpasses as test failures so they get converted to regular tests as soon as possible
-xfail_strict = true
diff --git a/setup.cfg b/setup.cfg
deleted file mode 100644
index 04d75ac8d19f2..0000000000000
--- a/setup.cfg
+++ /dev/null
@@ -1,16 +0,0 @@
-[coverage:run]
-branch = true
-source = mypy
-parallel = true
-
-[coverage:report]
-show_missing = true
-skip_covered = True
-omit = mypy/test/*
-exclude_lines =
-    \#\s*pragma: no cover
-    ^\s*raise AssertionError\b
-    ^\s*raise NotImplementedError\b
-    ^\s*return NotImplemented\b
-    ^\s*raise$
-    ^if __name__ == ['"]__main__['"]:$

From 95dde9d8dc9007b28881eee10231bdd8ae0c9d43 Mon Sep 17 00:00:00 2001
From: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
Date: Thu, 29 Jun 2023 13:43:50 -0700
Subject: [PATCH 087/129] Switch pre-commit to using mypyc compiled Black
 wheels (#15544)

---
 .pre-commit-config.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 1ad273ce55844..a56e1af938b8c 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -5,7 +5,7 @@ repos:
     hooks:
       - id: trailing-whitespace
       - id: end-of-file-fixer
-  - repo: https://github.com/psf/black
+  - repo: https://github.com/hauntsaninja/black-pre-commit-mirror
     rev: 23.3.0  # must match test-requirements.txt
     hooks:
       - id: black

From b995e1620789a3ab2fc5dbcf0698a9077b0f5731 Mon Sep 17 00:00:00 2001
From: Ivan Levkivskyi <levkivskyi@gmail.com>
Date: Thu, 29 Jun 2023 23:34:15 +0100
Subject: [PATCH 088/129] Rebind self-types in subclass methods without Self
 annotation (#15541)

Fixes #15529

The fix is straightforward, hopefully there will be no fallout. (Note
that #14075 would also fix this, but I am still not sure we should do
that)

---------

Co-authored-by: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
---
 mypy/checkmember.py                | 14 ++++++++++++--
 mypy/plugins/dataclasses.py        |  3 ++-
 mypy/semanal.py                    |  2 ++
 test-data/unit/check-selftype.test | 17 +++++++++++++++++
 test-data/unit/pythoneval.test     | 17 +++++++++++++++++
 5 files changed, 50 insertions(+), 3 deletions(-)

diff --git a/mypy/checkmember.py b/mypy/checkmember.py
index 7af61a532b7b0..36fea9daa3e38 100644
--- a/mypy/checkmember.py
+++ b/mypy/checkmember.py
@@ -735,12 +735,12 @@ def analyze_var(
     """Analyze access to an attribute via a Var node.
 
     This is conceptually part of analyze_member_access and the arguments are similar.
-
-    itype is the class object in which var is defined
+    itype is the instance type in which attribute should be looked up
     original_type is the type of E in the expression E.var
     if implicit is True, the original Var was created as an assignment to self
     """
     # Found a member variable.
+    original_itype = itype
     itype = map_instance_to_supertype(itype, var.info)
     typ = var.type
     if typ:
@@ -756,6 +756,16 @@ def analyze_var(
             get_proper_type(mx.original_type)
         ):
             t = expand_self_type(var, t, mx.original_type)
+        elif (
+            mx.is_self
+            and original_itype.type != var.info
+            # If an attribute with Self-type was defined in a supertype, we need to
+            # rebind the Self type variable to Self type variable of current class...
+            and original_itype.type.self_type is not None
+            # ...unless `self` has an explicit non-trivial annotation.
+            and original_itype == mx.chk.scope.active_self_type()
+        ):
+            t = expand_self_type(var, t, original_itype.type.self_type)
         t = get_proper_type(expand_type_by_instance(t, itype))
         freeze_all_type_vars(t)
         result: Type = t
diff --git a/mypy/plugins/dataclasses.py b/mypy/plugins/dataclasses.py
index bb3009dddf10b..9e054493828f2 100644
--- a/mypy/plugins/dataclasses.py
+++ b/mypy/plugins/dataclasses.py
@@ -355,7 +355,8 @@ def transform(self) -> bool:
         self._add_dataclass_fields_magic_attribute()
 
         if self._spec is _TRANSFORM_SPEC_FOR_DATACLASSES:
-            self._add_internal_replace_method(attributes)
+            with state.strict_optional_set(self._api.options.strict_optional):
+                self._add_internal_replace_method(attributes)
         if "__post_init__" in info.names:
             self._add_internal_post_init_method(attributes)
 
diff --git a/mypy/semanal.py b/mypy/semanal.py
index 1eb14e499e4d8..25393096bc5f0 100644
--- a/mypy/semanal.py
+++ b/mypy/semanal.py
@@ -1692,6 +1692,8 @@ def is_core_builtin_class(self, defn: ClassDef) -> bool:
     def analyze_class_body_common(self, defn: ClassDef) -> None:
         """Parts of class body analysis that are common to all kinds of class defs."""
         self.enter_class(defn.info)
+        if any(b.self_type is not None for b in defn.info.mro):
+            self.setup_self_type()
         defn.defs.accept(self)
         self.apply_class_plugin_hooks(defn)
         self.leave_class()
diff --git a/test-data/unit/check-selftype.test b/test-data/unit/check-selftype.test
index 53c24584cb736..96d5b2306427f 100644
--- a/test-data/unit/check-selftype.test
+++ b/test-data/unit/check-selftype.test
@@ -1867,3 +1867,20 @@ class B:
             return B()  # E: Incompatible return value type (got "B", expected "A")
 
 [builtins fixtures/isinstancelist.pyi]
+
+[case testAttributeOnSelfAttributeInSubclass]
+from typing import List, Self
+
+class A:
+    x: Self
+    xs: List[Self]
+
+class B(A):
+    extra: int
+
+    def meth(self) -> None:
+        reveal_type(self.x)  # N: Revealed type is "Self`0"
+        reveal_type(self.xs[0])  # N: Revealed type is "Self`0"
+        reveal_type(self.x.extra)  # N: Revealed type is "builtins.int"
+        reveal_type(self.xs[0].extra)  # N: Revealed type is "builtins.int"
+[builtins fixtures/list.pyi]
diff --git a/test-data/unit/pythoneval.test b/test-data/unit/pythoneval.test
index b43dcbd7088fb..1460002e1b656 100644
--- a/test-data/unit/pythoneval.test
+++ b/test-data/unit/pythoneval.test
@@ -2092,3 +2092,20 @@ def fst(kv: Tuple[K, V]) -> K:
 pairs = [(len(s), s) for s in ["one", "two", "three"]]
 grouped = groupby(pairs, key=fst)
 [out]
+
+[case testDataclassReplaceOptional]
+# flags: --strict-optional
+from dataclasses import dataclass, replace
+from typing import Optional
+
+@dataclass
+class A:
+    x: Optional[int]
+
+a = A(x=42)
+reveal_type(a)
+a2 = replace(a, x=None)  # OK
+reveal_type(a2)
+[out]
+_testDataclassReplaceOptional.py:10: note: Revealed type is "_testDataclassReplaceOptional.A"
+_testDataclassReplaceOptional.py:12: note: Revealed type is "_testDataclassReplaceOptional.A"

From 21beadc0aef5149111ae88504ec1514b943d4f78 Mon Sep 17 00:00:00 2001
From: Alex Waygood <Alex.Waygood@Gmail.com>
Date: Fri, 30 Jun 2023 16:41:30 +0100
Subject: [PATCH 089/129] Enforce typing_extensions >=4.7.0 on py37 (#15556)

The changes made in #15543 mean that mypy's tests will no longer pass if
you've got `typing_extensions<4.7` installed and you're running on
Python 3.7.
---
 mypy-requirements.txt     |  3 ++-
 mypyc/irbuild/classdef.py | 10 ++++++++--
 pyproject.toml            |  3 ++-
 setup.py                  |  3 ++-
 4 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/mypy-requirements.txt b/mypy-requirements.txt
index 7043765f09f4e..ba6f069661adf 100644
--- a/mypy-requirements.txt
+++ b/mypy-requirements.txt
@@ -1,5 +1,6 @@
 # NOTE: this needs to be kept in sync with the "requires" list in pyproject.toml
-typing_extensions>=4.1.0
+typing_extensions>=4.1.0; python_version >= '3.8'
+typing_extensions>=4.7.0; python_version < '3.8'
 mypy_extensions>=1.0.0
 typed_ast>=1.4.0,<2; python_version<'3.8'
 tomli>=1.1.0; python_version<'3.11'
diff --git a/mypyc/irbuild/classdef.py b/mypyc/irbuild/classdef.py
index fcb2afba0939f..ef8db97c818e2 100644
--- a/mypyc/irbuild/classdef.py
+++ b/mypyc/irbuild/classdef.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import typing_extensions
 from abc import abstractmethod
 from typing import Callable
 from typing_extensions import Final
@@ -498,9 +499,14 @@ def populate_non_ext_bases(builder: IRBuilder, cdef: ClassDef) -> Value:
                 if builder.options.capi_version < (3, 8):
                     # TypedDict was added to typing in Python 3.8.
                     module = "typing_extensions"
-                    # It needs to be "_TypedDict" on typing_extensions 4.7.0+
-                    # and "TypedDict" otherwise.
+                    # TypedDict is not a real type on typing_extensions 4.7.0+
                     name = "_TypedDict"
+                    if isinstance(typing_extensions.TypedDict, type):
+                        raise RuntimeError(
+                            "It looks like you may have an old version "
+                            "of typing_extensions installed. "
+                            "typing_extensions>=4.7.0 is required on Python 3.7."
+                        )
             else:
                 # In Python 3.9 TypedDict is not a real type.
                 name = "_TypedDict"
diff --git a/pyproject.toml b/pyproject.toml
index 0b14dd419d08c..96a05d545946a 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -6,7 +6,8 @@ requires = [
     "setuptools >= 40.6.2",
     "wheel >= 0.30.0",
     # the following is from mypy-requirements.txt
-    "typing_extensions>=4.1.0",
+    "typing_extensions>=4.1.0; python_version >= '3.8'",
+    "typing_extensions>=4.7.0; python_version < '3.8'",
     "mypy_extensions>=1.0.0",
     "typed_ast>=1.4.0,<2; python_version<'3.8'",
     "tomli>=1.1.0; python_version<'3.11'",
diff --git a/setup.py b/setup.py
index 81494a5566e8b..85d412540013e 100644
--- a/setup.py
+++ b/setup.py
@@ -222,7 +222,8 @@ def run(self):
     # When changing this, also update mypy-requirements.txt.
     install_requires=[
         "typed_ast >= 1.4.0, < 2; python_version<'3.8'",
-        "typing_extensions>=4.1.0",
+        "typing_extensions>=4.1.0; python_version >= '3.8'",
+        "typing_extensions>=4.7.0; python_version < '3.8'",
         "mypy_extensions >= 1.0.0",
         "tomli>=1.1.0; python_version<'3.11'",
     ],

From 92602c523975495af544bd493d0bd59d15334440 Mon Sep 17 00:00:00 2001
From: Richard Si <sichard26@gmail.com>
Date: Fri, 30 Jun 2023 11:47:00 -0400
Subject: [PATCH 090/129] [mypyc] Document more unsupported features & update
 supported features (#15524)

Towards mypyc/mypyc#978.

---------

Co-authored-by: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Co-authored-by: Alex Waygood <Alex.Waygood@Gmail.com>
---
 mypyc/doc/differences_from_python.rst | 38 ++++++++++++++++++---------
 mypyc/doc/native_classes.rst          | 12 +++++++--
 mypyc/doc/using_type_annotations.rst  |  4 +--
 3 files changed, 38 insertions(+), 16 deletions(-)

diff --git a/mypyc/doc/differences_from_python.rst b/mypyc/doc/differences_from_python.rst
index 16faae60303fc..f1d4d05a3a871 100644
--- a/mypyc/doc/differences_from_python.rst
+++ b/mypyc/doc/differences_from_python.rst
@@ -268,19 +268,27 @@ used in compiled code, or there are some limitations. You can
 partially work around some of these limitations by running your code
 in interpreted mode.
 
-Operator overloading
-********************
+Nested classes
+**************
 
-Native classes can only use these dunder methods to override operators:
+Nested classes are not supported.
 
-* ``__eq__``
-* ``__ne__``
-* ``__getitem__``
-* ``__setitem__``
+Conditional functions or classes
+********************************
 
-.. note::
+Function and class definitions guarded by an if-statement are not supported.
+
+Dunder methods
+**************
 
-    This limitation will be lifted in the future.
+Native classes **cannot** use these dunders. If defined, they will not
+work as expected.
+
+* ``__del__``
+* ``__index__``
+* ``__getattr__``, ``__getattribute__``
+* ``__setattr__``
+* ``__delattr__``
 
 Generator expressions
 *********************
@@ -299,10 +307,16 @@ Descriptors
 Native classes can't contain arbitrary descriptors. Properties, static
 methods and class methods are supported.
 
-Stack introspection
-*******************
+Introspection
+*************
+
+Various methods of introspection may break by using mypyc. Here's an
+non-exhaustive list of what won't work:
 
-Frames of compiled functions can't be inspected using ``inspect``.
+- Instance ``__annotations__`` is usually not kept
+- Frames of compiled functions can't be inspected using ``inspect``
+- Compiled methods aren't considered methods by ``inspect.ismethod``
+- ``inspect.signature`` chokes on compiled functions
 
 Profiling hooks and tracing
 ***************************
diff --git a/mypyc/doc/native_classes.rst b/mypyc/doc/native_classes.rst
index 2b4a0892b7905..b2935a6f71856 100644
--- a/mypyc/doc/native_classes.rst
+++ b/mypyc/doc/native_classes.rst
@@ -63,6 +63,8 @@ classes:
 * ``IndexError``
 * ``LookupError``
 * ``UserWarning``
+* ``typing.NamedTuple``
+* ``enum.Enum``
 
 By default, a non-native class can't inherit a native class, and you
 can't inherit from a native class outside the compilation unit that
@@ -104,6 +106,11 @@ through an instance. Example::
     print(o.cv)  # OK (2)
     o.cv = 3  # Error!
 
+.. tip::
+
+    Constant class variables can be declared using ``typing.Final`` or
+    ``typing.Final[<type>]``.
+
 Generic native classes
 ----------------------
 
@@ -150,9 +157,10 @@ decorators can be used with native classes, however:
 * ``mypy_extensions.trait`` (for defining :ref:`trait types <trait-types>`)
 * ``mypy_extensions.mypyc_attr`` (see :ref:`above <inheritance>`)
 * ``dataclasses.dataclass``
+* ``@attr.s(auto_attribs=True)``
 
-Dataclasses have partial native support, and they aren't as efficient
-as pure native classes.
+Dataclasses and attrs classes have partial native support, and they aren't as
+efficient as pure native classes.
 
 .. note::
 
diff --git a/mypyc/doc/using_type_annotations.rst b/mypyc/doc/using_type_annotations.rst
index f095a67172717..5bfff388e4331 100644
--- a/mypyc/doc/using_type_annotations.rst
+++ b/mypyc/doc/using_type_annotations.rst
@@ -194,8 +194,8 @@ Traits have some special properties:
 * You shouldn't create instances of traits (though mypyc does not
   prevent it yet).
 
-* Traits can subclass other traits, but they can't subclass non-trait
-  classes (other than ``object``).
+* Traits can subclass other traits or native classes, but the MRO must be
+  linear (just like with native classes).
 
 * Accessing methods or attributes through a trait type is somewhat
   less efficient than through a native class type, but this is much

From 3730899fce2917e312511dc68d813e5dc42d5685 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Sat, 1 Jul 2023 17:35:52 +0100
Subject: [PATCH 091/129] Define mypy_extensions.i16 in stubs (#15562)

I forgot to add this when I added mypyc support for the i16 native
integer type.

The mypy_extensions stubs are maintained here instead of typeshed.

This is a copy of the stubs for `i32`, with references to `i32` replaced
with `i16`.
---
 .../stubs/mypy-extensions/mypy_extensions.pyi | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/mypy/typeshed/stubs/mypy-extensions/mypy_extensions.pyi b/mypy/typeshed/stubs/mypy-extensions/mypy_extensions.pyi
index 40e24645fb772..86a071500b34b 100644
--- a/mypy/typeshed/stubs/mypy-extensions/mypy_extensions.pyi
+++ b/mypy/typeshed/stubs/mypy-extensions/mypy_extensions.pyi
@@ -146,3 +146,38 @@ class i32:
     def __ge__(self, x: i32) -> bool: ...
     def __gt__(self, x: i32) -> bool: ...
     def __index__(self) -> int: ...
+
+class i16:
+    @overload
+    def __new__(cls, __x: str | ReadableBuffer | SupportsInt | SupportsIndex | SupportsTrunc = ...) -> i16: ...
+    @overload
+    def __new__(cls, __x: str | bytes | bytearray, base: SupportsIndex) -> i16: ...
+
+    def __add__(self, x: i16) -> i16: ...
+    def __radd__(self, x: i16) -> i16: ...
+    def __sub__(self, x: i16) -> i16: ...
+    def __rsub__(self, x: i16) -> i16: ...
+    def __mul__(self, x: i16) -> i16: ...
+    def __rmul__(self, x: i16) -> i16: ...
+    def __floordiv__(self, x: i16) -> i16: ...
+    def __rfloordiv__(self, x: i16) -> i16: ...
+    def __mod__(self, x: i16) -> i16: ...
+    def __rmod__(self, x: i16) -> i16: ...
+    def __and__(self, x: i16) -> i16: ...
+    def __rand__(self, x: i16) -> i16: ...
+    def __or__(self, x: i16) -> i16: ...
+    def __ror__(self, x: i16) -> i16: ...
+    def __xor__(self, x: i16) -> i16: ...
+    def __rxor__(self, x: i16) -> i16: ...
+    def __lshift__(self, x: i16) -> i16: ...
+    def __rlshift__(self, x: i16) -> i16: ...
+    def __rshift__(self, x: i16) -> i16: ...
+    def __rrshift__(self, x: i16) -> i16: ...
+    def __neg__(self) -> i16: ...
+    def __invert__(self) -> i16: ...
+    def __pos__(self) -> i16: ...
+    def __lt__(self, x: i16) -> bool: ...
+    def __le__(self, x: i16) -> bool: ...
+    def __ge__(self, x: i16) -> bool: ...
+    def __gt__(self, x: i16) -> bool: ...
+    def __index__(self) -> int: ...

From 19c5d5f7848a94c810c8d840a42e29ffe3f8906f Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Sat, 1 Jul 2023 17:36:42 +0100
Subject: [PATCH 092/129] [mypyc] Improve failure reporting in default run test
 driver (#15563)

Fix stdout flushing to avoid empty lines getting out of alignment with
the rest of the output.

Display the name of a failed test function, since it's sometimes not
visible in the traceback (at least if something incorrectly propagates exceptions).
---
 mypyc/test-data/driver/driver.py | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/mypyc/test-data/driver/driver.py b/mypyc/test-data/driver/driver.py
index 6717f402f72d2..c9d179224a30d 100644
--- a/mypyc/test-data/driver/driver.py
+++ b/mypyc/test-data/driver/driver.py
@@ -18,7 +18,7 @@
         try:
             test_func()
         except Exception as e:
-            failures.append(sys.exc_info())
+            failures.append((name, sys.exc_info()))
 
 if failures:
     from traceback import print_exception, format_tb
@@ -32,12 +32,17 @@ def extract_line(tb):
         return m.group(1)
 
     # Sort failures by line number of test function.
-    failures = sorted(failures, key=lambda e: extract_line(e[2]))
+    failures = sorted(failures, key=lambda e: extract_line(e[1][2]))
 
     # If there are multiple failures, print stack traces of all but the final failure.
-    for e in failures[:-1]:
+    for name, e in failures[:-1]:
+        print(f'<< {name} >>')
+        sys.stdout.flush()
         print_exception(*e)
         print()
+        sys.stdout.flush()
 
     # Raise exception for the last failure. Test runner will show the traceback.
-    raise failures[-1][1]
+    print(f'<< {failures[-1][0]} >>')
+    sys.stdout.flush()
+    raise failures[-1][1][1]

From 2edaf35ec1f91c139dfe1930b1b0d1e1cac59599 Mon Sep 17 00:00:00 2001
From: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
Date: Sun, 2 Jul 2023 18:59:35 -0700
Subject: [PATCH 093/129] Drop support for running with Python 3.7 (#15566)

---
 .github/workflows/docs.yml                    |   2 +-
 .github/workflows/test.yml                    |  49 ++--
 build-requirements.txt                        |   1 -
 docs/source/additional_features.rst           |   7 +-
 docs/source/getting_started.rst               |   2 +-
 misc/build-debug-python.sh                    |   2 +-
 mypy-requirements.txt                         |   4 +-
 mypy/defaults.py                              |   2 +-
 mypy/dmypy_server.py                          |   2 -
 mypy/fastparse.py                             | 271 +++++-------------
 mypy/messages.py                              |   2 +
 mypy/pyinfo.py                                |   8 +-
 mypy/test/meta/test_update_data.py            |   5 +-
 mypy/test/testcheck.py                        |   4 +-
 mypy/test/testdaemon.py                       |   4 -
 mypy/test/testfinegrained.py                  |   5 +-
 mypy/test/testpep561.py                       |   5 -
 mypy/test/teststubgen.py                      |   1 +
 mypy/test/teststubtest.py                     |  73 +++--
 mypy/util.py                                  |   6 +-
 mypy_self_check.ini                           |   2 +-
 mypyc/test/test_run.py                        |   6 +-
 pyproject.toml                                |   5 +-
 setup.py                                      |  13 +-
 test-data/unit/check-columns.test             |   4 -
 test-data/unit/check-incremental.test         |   4 +-
 .../unit/check-parameter-specification.test   |   7 -
 test-data/unit/check-typeguard.test           |   4 -
 test-data/unit/cmdline.test                   |  21 --
 test-data/unit/daemon.test                    |   8 +-
 test-data/unit/fine-grained-blockers.test     |  10 -
 .../unit/fine-grained-cache-incremental.test  |   6 +-
 test-data/unit/fine-grained.test              |  22 --
 test-data/unit/pythoneval.test                |   2 +-
 test-data/unit/semanal-errors.test            |  38 ---
 test-data/unit/semanal-statements.test        |   2 -
 36 files changed, 163 insertions(+), 446 deletions(-)

diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 3e06b5e909f13..5dc86a1159f45 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -25,7 +25,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-python@v4
         with:
-          python-version: '3.7'
+          python-version: '3.8'
       - name: Install tox
         run: pip install --upgrade 'setuptools!=50' tox==4.4.4
       - name: Setup tox environment
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 5bd20f2773c59..05e52ad95a175 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -26,37 +26,27 @@ jobs:
       fail-fast: false
       matrix:
         include:
-        - name: Test suite with py37-windows-64
-          python: '3.7'
-          arch: x64
-          os: windows-latest
-          toxenv: py37
-        - name: Test suite with py38-ubuntu
+        # Make sure to run mypyc compiled unit tests for both
+        # the oldest and newest supported Python versions
+        - name: Test suite with py38-ubuntu, mypyc-compiled
           python: '3.8'
           arch: x64
           os: ubuntu-latest
           toxenv: py
           tox_extra_args: "-n 2"
-        - name: Test suite with py39-ubuntu
-          python: '3.9'
-          arch: x64
-          os: ubuntu-latest
-          toxenv: py
-          tox_extra_args: "-n 2"
-        - name: Test suite with py37-ubuntu, mypyc-compiled
-          python: '3.7'
+          test_mypyc: true
+        - name: Test suite with py38-windows-64
+          python: '3.8'
           arch: x64
-          os: ubuntu-latest
-          toxenv: py
+          os: windows-latest
+          toxenv: py38
           tox_extra_args: "-n 2"
-          test_mypyc: true
-        - name: Test suite with py310-ubuntu, mypyc-compiled
-          python: '3.10'
+        - name: Test suite with py39-ubuntu
+          python: '3.9'
           arch: x64
           os: ubuntu-latest
           toxenv: py
           tox_extra_args: "-n 2"
-          test_mypyc: true
         - name: Test suite with py310-ubuntu
           python: '3.10'
           arch: x64
@@ -70,29 +60,32 @@ jobs:
           toxenv: py
           tox_extra_args: "-n 2"
           test_mypyc: true
-        - name: mypyc runtime tests with py37-macos
-          python: '3.7'
+
+        - name: mypyc runtime tests with py38-macos
+          python: '3.8.17'
           arch: x64
           os: macos-latest
           toxenv: py
           tox_extra_args: "-n 2 mypyc/test/test_run.py mypyc/test/test_external.py"
-        - name: mypyc runtime tests with py37-debug-build-ubuntu
-          python: '3.7.13'
+        - name: mypyc runtime tests with py38-debug-build-ubuntu
+          python: '3.8.17'
           arch: x64
           os: ubuntu-latest
           toxenv: py
           tox_extra_args: "-n 2 mypyc/test/test_run.py mypyc/test/test_external.py"
           debug_build: true
-        - name: Type check our own code (py37-ubuntu)
-          python: '3.7'
+
+        - name: Type check our own code (py38-ubuntu)
+          python: '3.8'
           arch: x64
           os: ubuntu-latest
           toxenv: type
-        - name: Type check our own code (py37-windows-64)
-          python: '3.7'
+        - name: Type check our own code (py38-windows-64)
+          python: '3.8'
           arch: x64
           os: windows-latest
           toxenv: type
+
           # We also run these checks with pre-commit in CI,
           # but it's useful to run them with tox too,
           # to ensure the tox env works as expected
diff --git a/build-requirements.txt b/build-requirements.txt
index 0b1e6d43103a6..aac1b95eddf7b 100644
--- a/build-requirements.txt
+++ b/build-requirements.txt
@@ -2,4 +2,3 @@
 -r mypy-requirements.txt
 types-psutil
 types-setuptools
-types-typed-ast>=1.5.8.5,<1.6.0
diff --git a/docs/source/additional_features.rst b/docs/source/additional_features.rst
index 10122e9b2fa9a..5dd136476eaa8 100644
--- a/docs/source/additional_features.rst
+++ b/docs/source/additional_features.rst
@@ -9,10 +9,9 @@ of the previous sections.
 Dataclasses
 ***********
 
-In Python 3.7, a new :py:mod:`dataclasses` module has been added to the standard library.
-This module allows defining and customizing simple boilerplate-free classes.
-They can be defined using the :py:func:`@dataclasses.dataclass
-<python:dataclasses.dataclass>` decorator:
+The :py:mod:`dataclasses` module allows defining and customizing simple
+boilerplate-free classes. They can be defined using the
+:py:func:`@dataclasses.dataclass <python:dataclasses.dataclass>` decorator:
 
 .. code-block:: python
 
diff --git a/docs/source/getting_started.rst b/docs/source/getting_started.rst
index 9b927097cfd20..11f915005695a 100644
--- a/docs/source/getting_started.rst
+++ b/docs/source/getting_started.rst
@@ -16,7 +16,7 @@ may not make much sense otherwise.
 Installing and running mypy
 ***************************
 
-Mypy requires Python 3.7 or later to run.  You can install mypy using pip:
+Mypy requires Python 3.8 or later to run.  You can install mypy using pip:
 
 .. code-block:: shell
 
diff --git a/misc/build-debug-python.sh b/misc/build-debug-python.sh
index f652d6ad9937d..8dd1bff4c9ed1 100755
--- a/misc/build-debug-python.sh
+++ b/misc/build-debug-python.sh
@@ -26,7 +26,7 @@ fi
 curl -O https://www.python.org/ftp/python/$VERSION/Python-$VERSION.tgz
 tar zxf Python-$VERSION.tgz
 cd Python-$VERSION
-CPPFLAGS="$CPPFLAGS" LDFLAGS="$LDFLAGS" ./configure CFLAGS="-DPy_DEBUG -DPy_TRACE_REFS -DPYMALLOC_DEBUG" --with-pydebug --prefix=$PREFIX
+CPPFLAGS="$CPPFLAGS" LDFLAGS="$LDFLAGS" ./configure CFLAGS="-DPy_DEBUG -DPy_TRACE_REFS -DPYMALLOC_DEBUG" --with-pydebug --prefix=$PREFIX --with-trace-refs
 make -j4
 make install
 $PREFIX/bin/python3 -m pip install virtualenv
diff --git a/mypy-requirements.txt b/mypy-requirements.txt
index ba6f069661adf..f81412be761e8 100644
--- a/mypy-requirements.txt
+++ b/mypy-requirements.txt
@@ -1,6 +1,4 @@
 # NOTE: this needs to be kept in sync with the "requires" list in pyproject.toml
-typing_extensions>=4.1.0; python_version >= '3.8'
-typing_extensions>=4.7.0; python_version < '3.8'
+typing_extensions>=4.1.0
 mypy_extensions>=1.0.0
-typed_ast>=1.4.0,<2; python_version<'3.8'
 tomli>=1.1.0; python_version<'3.11'
diff --git a/mypy/defaults.py b/mypy/defaults.py
index d167997464f44..59a99cd58888c 100644
--- a/mypy/defaults.py
+++ b/mypy/defaults.py
@@ -8,7 +8,7 @@
 # Earliest fully supported Python 3.x version. Used as the default Python
 # version in tests. Mypy wheels should be built starting with this version,
 # and CI tests should be run on this version (and later versions).
-PYTHON3_VERSION: Final = (3, 7)
+PYTHON3_VERSION: Final = (3, 8)
 
 # Earliest Python 3.x version supported via --python-version 3.x. To run
 # mypy, at least version PYTHON3_VERSION is needed.
diff --git a/mypy/dmypy_server.py b/mypy/dmypy_server.py
index 54544f4c01ce4..2427f83c57674 100644
--- a/mypy/dmypy_server.py
+++ b/mypy/dmypy_server.py
@@ -896,8 +896,6 @@ def cmd_inspect(
         force_reload: bool = False,
     ) -> dict[str, object]:
         """Locate and inspect expression(s)."""
-        if sys.version_info < (3, 8):
-            return {"error": 'Python 3.8 required for "inspect" command'}
         if not self.fine_grained_manager:
             return {
                 "error": 'Command "inspect" is only valid after a "check" command'
diff --git a/mypy/fastparse.py b/mypy/fastparse.py
index fe59ff48bdfcf..3f4e2f4c927d1 100644
--- a/mypy/fastparse.py
+++ b/mypy/fastparse.py
@@ -118,123 +118,57 @@
 )
 from mypy.util import bytes_to_human_readable_repr, unnamed_function
 
-try:
-    # pull this into a final variable to make mypyc be quiet about the
-    # the default argument warning
-    PY_MINOR_VERSION: Final = sys.version_info[1]
-
-    # Check if we can use the stdlib ast module instead of typed_ast.
-    if sys.version_info >= (3, 8):
-        import ast as ast3
-
-        assert (
-            "kind" in ast3.Constant._fields
-        ), f"This 3.8.0 alpha ({sys.version.split()[0]}) is too old; 3.8.0a3 required"
-        # TODO: Num, Str, Bytes, NameConstant, Ellipsis are deprecated in 3.8.
-        # TODO: Index, ExtSlice are deprecated in 3.9.
-        from ast import (
-            AST,
-            Attribute,
-            Bytes,
-            Call,
-            Ellipsis as ast3_Ellipsis,
-            Expression as ast3_Expression,
-            FunctionType,
-            Index,
-            Name,
-            NameConstant,
-            Num,
-            Starred,
-            Str,
-            UnaryOp,
-            USub,
-        )
+# pull this into a final variable to make mypyc be quiet about the
+# the default argument warning
+PY_MINOR_VERSION: Final = sys.version_info[1]
 
-        def ast3_parse(
-            source: str | bytes, filename: str, mode: str, feature_version: int = PY_MINOR_VERSION
-        ) -> AST:
-            return ast3.parse(
-                source,
-                filename,
-                mode,
-                type_comments=True,  # This works the magic
-                feature_version=feature_version,
-            )
+import ast as ast3
 
-        NamedExpr = ast3.NamedExpr
-        Constant = ast3.Constant
-    else:
-        from typed_ast import ast3
-        from typed_ast.ast3 import (
-            AST,
-            Attribute,
-            Bytes,
-            Call,
-            Ellipsis as ast3_Ellipsis,
-            Expression as ast3_Expression,
-            FunctionType,
-            Index,
-            Name,
-            NameConstant,
-            Num,
-            Starred,
-            Str,
-            UnaryOp,
-            USub,
-        )
+# TODO: Index, ExtSlice are deprecated in 3.9.
+from ast import AST, Attribute, Call, FunctionType, Index, Name, Starred, UnaryOp, USub
 
-        def ast3_parse(
-            source: str | bytes, filename: str, mode: str, feature_version: int = PY_MINOR_VERSION
-        ) -> AST:
-            return ast3.parse(source, filename, mode, feature_version=feature_version)
-
-        # These don't exist before 3.8
-        NamedExpr = Any
-        Constant = Any
-
-    if sys.version_info >= (3, 10):
-        Match = ast3.Match
-        MatchValue = ast3.MatchValue
-        MatchSingleton = ast3.MatchSingleton
-        MatchSequence = ast3.MatchSequence
-        MatchStar = ast3.MatchStar
-        MatchMapping = ast3.MatchMapping
-        MatchClass = ast3.MatchClass
-        MatchAs = ast3.MatchAs
-        MatchOr = ast3.MatchOr
-        AstNode = Union[ast3.expr, ast3.stmt, ast3.pattern, ast3.ExceptHandler]
-    else:
-        Match = Any
-        MatchValue = Any
-        MatchSingleton = Any
-        MatchSequence = Any
-        MatchStar = Any
-        MatchMapping = Any
-        MatchClass = Any
-        MatchAs = Any
-        MatchOr = Any
-        AstNode = Union[ast3.expr, ast3.stmt, ast3.ExceptHandler]
-    if sys.version_info >= (3, 11):
-        TryStar = ast3.TryStar
-    else:
-        TryStar = Any
-except ImportError:
-    try:
-        from typed_ast import ast35  # type: ignore[attr-defined]  # noqa: F401
-    except ImportError:
-        print(
-            "The typed_ast package is not installed.\n"
-            "You can install it with `python3 -m pip install typed-ast`.",
-            file=sys.stderr,
-        )
-    else:
-        print(
-            "You need a more recent version of the typed_ast package.\n"
-            "You can update to the latest version with "
-            "`python3 -m pip install -U typed-ast`.",
-            file=sys.stderr,
-        )
-    sys.exit(1)
+
+def ast3_parse(
+    source: str | bytes, filename: str, mode: str, feature_version: int = PY_MINOR_VERSION
+) -> AST:
+    return ast3.parse(
+        source,
+        filename,
+        mode,
+        type_comments=True,  # This works the magic
+        feature_version=feature_version,
+    )
+
+
+NamedExpr = ast3.NamedExpr
+Constant = ast3.Constant
+
+if sys.version_info >= (3, 10):
+    Match = ast3.Match
+    MatchValue = ast3.MatchValue
+    MatchSingleton = ast3.MatchSingleton
+    MatchSequence = ast3.MatchSequence
+    MatchStar = ast3.MatchStar
+    MatchMapping = ast3.MatchMapping
+    MatchClass = ast3.MatchClass
+    MatchAs = ast3.MatchAs
+    MatchOr = ast3.MatchOr
+    AstNode = Union[ast3.expr, ast3.stmt, ast3.pattern, ast3.ExceptHandler]
+else:
+    Match = Any
+    MatchValue = Any
+    MatchSingleton = Any
+    MatchSequence = Any
+    MatchStar = Any
+    MatchMapping = Any
+    MatchClass = Any
+    MatchAs = Any
+    MatchOr = Any
+    AstNode = Union[ast3.expr, ast3.stmt, ast3.ExceptHandler]
+if sys.version_info >= (3, 11):
+    TryStar = ast3.TryStar
+else:
+    TryStar = Any
 
 N = TypeVar("N", bound=Node)
 
@@ -370,7 +304,7 @@ def parse_type_comment(
                     raise SyntaxError
         else:
             ignored = None
-        assert isinstance(typ, ast3_Expression)
+        assert isinstance(typ, ast3.Expression)
         converted = TypeConverter(
             errors, line=line, override_column=column, is_evaluated=False
         ).visit(typ.body)
@@ -961,8 +895,10 @@ def do_func_def(
                 func_type_ast = ast3_parse(n.type_comment, "<func_type>", "func_type")
                 assert isinstance(func_type_ast, FunctionType)
                 # for ellipsis arg
-                if len(func_type_ast.argtypes) == 1 and isinstance(
-                    func_type_ast.argtypes[0], ast3_Ellipsis
+                if (
+                    len(func_type_ast.argtypes) == 1
+                    and isinstance(func_type_ast.argtypes[0], Constant)
+                    and func_type_ast.argtypes[0].value is Ellipsis
                 ):
                     if n.returns:
                         # PEP 484 disallows both type annotations and type comments
@@ -1052,15 +988,9 @@ def do_func_def(
             func_type.line = lineno
 
         if n.decorator_list:
-            if sys.version_info < (3, 8):
-                # Before 3.8, [typed_]ast the line number points to the first decorator.
-                # In 3.8, it points to the 'def' line, where we want it.
-                deco_line = lineno
-                lineno += len(n.decorator_list)  # this is only approximately true
-            else:
-                # Set deco_line to the old pre-3.8 lineno, in order to keep
-                # existing "# type: ignore" comments working:
-                deco_line = n.decorator_list[0].lineno
+            # Set deco_line to the old pre-3.8 lineno, in order to keep
+            # existing "# type: ignore" comments working:
+            deco_line = n.decorator_list[0].lineno
 
             var = Var(func_def.name)
             var.is_ready = False
@@ -1188,12 +1118,9 @@ def visit_ClassDef(self, n: ast3.ClassDef) -> ClassDef:
         cdef.decorators = self.translate_expr_list(n.decorator_list)
         # Set lines to match the old mypy 0.700 lines, in order to keep
         # existing "# type: ignore" comments working:
-        if sys.version_info < (3, 8):
-            cdef.line = n.lineno + len(n.decorator_list)
-            cdef.deco_line = n.lineno
-        else:
-            cdef.line = n.lineno
-            cdef.deco_line = n.decorator_list[0].lineno if n.decorator_list else None
+        cdef.line = n.lineno
+        cdef.deco_line = n.decorator_list[0].lineno if n.decorator_list else None
+
         cdef.column = n.col_offset
         cdef.end_line = getattr(n, "end_lineno", None)
         cdef.end_column = getattr(n, "end_col_offset", None)
@@ -1580,9 +1507,9 @@ def visit_Constant(self, n: Constant) -> Any:
         if val is None:
             e = NameExpr("None")
         elif isinstance(val, str):
-            e = StrExpr(n.s)
+            e = StrExpr(val)
         elif isinstance(val, bytes):
-            e = BytesExpr(bytes_to_human_readable_repr(n.s))
+            e = BytesExpr(bytes_to_human_readable_repr(val))
         elif isinstance(val, bool):  # Must check before int!
             e = NameExpr(str(val))
         elif isinstance(val, int):
@@ -1597,28 +1524,6 @@ def visit_Constant(self, n: Constant) -> Any:
             raise RuntimeError("Constant not implemented for " + str(type(val)))
         return self.set_line(e, n)
 
-    # Num(object n) -- a number as a PyObject.
-    def visit_Num(self, n: ast3.Num) -> IntExpr | FloatExpr | ComplexExpr:
-        # The n field has the type complex, but complex isn't *really*
-        # a parent of int and float, and this causes isinstance below
-        # to think that the complex branch is always picked. Avoid
-        # this by throwing away the type.
-        val: object = n.n
-        if isinstance(val, int):
-            e: IntExpr | FloatExpr | ComplexExpr = IntExpr(val)
-        elif isinstance(val, float):
-            e = FloatExpr(val)
-        elif isinstance(val, complex):
-            e = ComplexExpr(val)
-        else:
-            raise RuntimeError("num not implemented for " + str(type(val)))
-        return self.set_line(e, n)
-
-    # Str(string s)
-    def visit_Str(self, n: Str) -> StrExpr:
-        e = StrExpr(n.s)
-        return self.set_line(e, n)
-
     # JoinedStr(expr* values)
     def visit_JoinedStr(self, n: ast3.JoinedStr) -> Expression:
         # Each of n.values is a str or FormattedValue; we just concatenate
@@ -1643,7 +1548,7 @@ def visit_FormattedValue(self, n: ast3.FormattedValue) -> Expression:
         # to allow mypyc to support f-strings with format specifiers and conversions.
         val_exp = self.visit(n.value)
         val_exp.set_line(n.lineno, n.col_offset)
-        conv_str = "" if n.conversion is None or n.conversion < 0 else "!" + chr(n.conversion)
+        conv_str = "" if n.conversion < 0 else "!" + chr(n.conversion)
         format_string = StrExpr("{" + conv_str + ":{}}")
         format_spec_exp = self.visit(n.format_spec) if n.format_spec is not None else StrExpr("")
         format_string.set_line(n.lineno, n.col_offset)
@@ -1654,21 +1559,6 @@ def visit_FormattedValue(self, n: ast3.FormattedValue) -> Expression:
         )
         return self.set_line(result_expression, n)
 
-    # Bytes(bytes s)
-    def visit_Bytes(self, n: ast3.Bytes) -> BytesExpr | StrExpr:
-        e = BytesExpr(bytes_to_human_readable_repr(n.s))
-        return self.set_line(e, n)
-
-    # NameConstant(singleton value)
-    def visit_NameConstant(self, n: NameConstant) -> NameExpr:
-        e = NameExpr(str(n.value))
-        return self.set_line(e, n)
-
-    # Ellipsis
-    def visit_Ellipsis(self, n: ast3_Ellipsis) -> EllipsisExpr:
-        e = EllipsisExpr()
-        return self.set_line(e, n)
-
     # Attribute(expr value, identifier attr, expr_context ctx)
     def visit_Attribute(self, n: Attribute) -> MemberExpr | SuperExpr:
         value = n.value
@@ -1955,9 +1845,9 @@ def translate_argument_list(self, l: Sequence[ast3.expr]) -> TypeList:
         return TypeList([self.visit(e) for e in l], line=self.line)
 
     def _extract_argument_name(self, n: ast3.expr) -> str | None:
-        if isinstance(n, Str):
-            return n.s.strip()
-        elif isinstance(n, NameConstant) and str(n.value) == "None":
+        if isinstance(n, Constant) and isinstance(n.value, str):
+            return n.value.strip()
+        elif isinstance(n, Constant) and n.value is None:
             return None
         self.fail(
             message_registry.ARG_NAME_EXPECTED_STRING_LITERAL.format(type(n).__name__),
@@ -1983,12 +1873,6 @@ def visit_BinOp(self, n: ast3.BinOp) -> Type:
             uses_pep604_syntax=True,
         )
 
-    def visit_NameConstant(self, n: NameConstant) -> Type:
-        if isinstance(n.value, bool):
-            return RawExpressionType(n.value, "builtins.bool", line=self.line)
-        else:
-            return UnboundType(str(n.value), line=self.line, column=n.col_offset)
-
     # Only for 3.8 and newer
     def visit_Constant(self, n: Constant) -> Type:
         val = n.value
@@ -2041,23 +1925,6 @@ def numeric_type(self, value: object, n: AST) -> Type:
             numeric_value, type_name, line=self.line, column=getattr(n, "col_offset", -1)
         )
 
-    # These next three methods are only used if we are on python <
-    # 3.8, using typed_ast.  They are defined unconditionally because
-    # mypyc can't handle conditional method definitions.
-
-    # Num(number n)
-    def visit_Num(self, n: Num) -> Type:
-        return self.numeric_type(n.n, n)
-
-    # Str(string s)
-    def visit_Str(self, n: Str) -> Type:
-        return parse_type_string(n.s, "builtins.str", self.line, n.col_offset)
-
-    # Bytes(bytes s)
-    def visit_Bytes(self, n: Bytes) -> Type:
-        contents = bytes_to_human_readable_repr(n.s)
-        return RawExpressionType(contents, "builtins.bytes", self.line, column=n.col_offset)
-
     def visit_Index(self, n: ast3.Index) -> Type:
         # cast for mypyc's benefit on Python 3.9
         value = self.visit(cast(Any, n).value)
@@ -2086,10 +1953,10 @@ def visit_Subscript(self, n: ast3.Subscript) -> Type:
             for s in dims:
                 if getattr(s, "col_offset", None) is None:
                     if isinstance(s, ast3.Index):
-                        s.col_offset = s.value.col_offset  # type: ignore[attr-defined]
+                        s.col_offset = s.value.col_offset
                     elif isinstance(s, ast3.Slice):
                         assert s.lower is not None
-                        s.col_offset = s.lower.col_offset  # type: ignore[attr-defined]
+                        s.col_offset = s.lower.col_offset
             sliceval = ast3.Tuple(dims, n.ctx)
 
         empty_tuple_index = False
@@ -2130,10 +1997,6 @@ def visit_Attribute(self, n: Attribute) -> Type:
         else:
             return self.invalid_type(n)
 
-    # Ellipsis
-    def visit_Ellipsis(self, n: ast3_Ellipsis) -> Type:
-        return EllipsisType(line=self.line)
-
     # List(expr* elts, expr_context ctx)
     def visit_List(self, n: ast3.List) -> Type:
         assert isinstance(n.ctx, ast3.Load)
diff --git a/mypy/messages.py b/mypy/messages.py
index ea7923c597782..8e59e73291682 100644
--- a/mypy/messages.py
+++ b/mypy/messages.py
@@ -235,6 +235,8 @@ def span_from_context(ctx: Context) -> Iterable[int]:
             Current logic is a bit tricky, to keep as much backwards compatibility as
             possible. We may reconsider this to always be a single line (or otherwise
             simplify it) when we drop Python 3.7.
+
+            TODO: address this in follow up PR
             """
             if isinstance(ctx, (ClassDef, FuncDef)):
                 return range(ctx.deco_line or ctx.line, ctx.line + 1)
diff --git a/mypy/pyinfo.py b/mypy/pyinfo.py
index 778b0b163ce6d..f262ac8b2132c 100644
--- a/mypy/pyinfo.py
+++ b/mypy/pyinfo.py
@@ -2,10 +2,10 @@
 
 """Utilities to find the site and prefix information of a Python executable.
 
-This file MUST remain compatible with all Python 3.7+ versions. Since we cannot make any assumptions about the
-Python being executed, this module should not use *any* dependencies outside of the standard
-library found in Python 3.7. This file is run each mypy run, so it should be kept as fast as
-possible.
+This file MUST remain compatible with all Python 3.8+ versions. Since we cannot make any
+assumptions about the Python being executed, this module should not use *any* dependencies outside
+of the standard library found in Python 3.8. This file is run each mypy run, so it should be kept
+as fast as possible.
 """
 import sys
 
diff --git a/mypy/test/meta/test_update_data.py b/mypy/test/meta/test_update_data.py
index 67f9a7f56ebd2..4e4bdd193dbfa 100644
--- a/mypy/test/meta/test_update_data.py
+++ b/mypy/test/meta/test_update_data.py
@@ -29,10 +29,7 @@ def _run_pytest_update_data(self, data_suite: str, *, max_attempts: int) -> str:
 
             test_nodeid = f"mypy/test/testcheck.py::TypeCheckSuite::{p.name}"
             args = [sys.executable, "-m", "pytest", "-n", "0", "-s", "--update-data", test_nodeid]
-            if sys.version_info >= (3, 8):
-                cmd = shlex.join(args)
-            else:
-                cmd = " ".join(args)
+            cmd = shlex.join(args)
             for i in range(max_attempts - 1, -1, -1):
                 res = subprocess.run(args, cwd=p_root)
                 if res.returncode == 0:
diff --git a/mypy/test/testcheck.py b/mypy/test/testcheck.py
index 58c0ee8033592..20dfbb77f3e04 100644
--- a/mypy/test/testcheck.py
+++ b/mypy/test/testcheck.py
@@ -36,9 +36,7 @@
 # Includes all check-* files with the .test extension in the test-data/unit directory
 typecheck_files = find_test_files(pattern="check-*.test")
 
-# Tests that use Python 3.8-only AST features (like expression-scoped ignores):
-if sys.version_info < (3, 8):
-    typecheck_files.remove("check-python38.test")
+# Tests that use Python version specific features:
 if sys.version_info < (3, 9):
     typecheck_files.remove("check-python39.test")
 if sys.version_info < (3, 10):
diff --git a/mypy/test/testdaemon.py b/mypy/test/testdaemon.py
index e3cdf44d89f2f..7115e682e60da 100644
--- a/mypy/test/testdaemon.py
+++ b/mypy/test/testdaemon.py
@@ -13,8 +13,6 @@
 import tempfile
 import unittest
 
-import pytest
-
 from mypy.dmypy_server import filter_out_missing_top_level_packages
 from mypy.fscache import FileSystemCache
 from mypy.modulefinder import SearchPaths
@@ -30,8 +28,6 @@ class DaemonSuite(DataSuite):
     files = daemon_files
 
     def run_case(self, testcase: DataDrivenTestCase) -> None:
-        if testcase.name.endswith("_python38") and sys.version_info < (3, 8):
-            pytest.skip("Not supported on this version of Python")
         try:
             test_daemon(testcase)
         finally:
diff --git a/mypy/test/testfinegrained.py b/mypy/test/testfinegrained.py
index 5b4c816b5c384..ba0526d325588 100644
--- a/mypy/test/testfinegrained.py
+++ b/mypy/test/testfinegrained.py
@@ -16,7 +16,6 @@
 
 import os
 import re
-import sys
 import unittest
 from typing import Any
 
@@ -70,9 +69,6 @@ def should_skip(self, testcase: DataDrivenTestCase) -> bool:
         else:
             if testcase.only_when == "-only_when_cache":
                 return True
-
-        if "Inspect" in testcase.name and sys.version_info < (3, 8):
-            return True
         return False
 
     def run_case(self, testcase: DataDrivenTestCase) -> None:
@@ -321,6 +317,7 @@ def maybe_suggest(self, step: int, server: Server, src: str, tmp_dir: str) -> li
                 # JSON contains already escaped \ on Windows, so requires a bit of care.
                 val = val.replace("\\\\", "\\")
                 val = val.replace(os.path.realpath(tmp_dir) + os.path.sep, "")
+                val = val.replace(os.path.abspath(tmp_dir) + os.path.sep, "")
             output.extend(val.strip().split("\n"))
         return normalize_messages(output)
 
diff --git a/mypy/test/testpep561.py b/mypy/test/testpep561.py
index da5025faef038..48d0658cd1e91 100644
--- a/mypy/test/testpep561.py
+++ b/mypy/test/testpep561.py
@@ -98,11 +98,6 @@ def test_pep561(testcase: DataDrivenTestCase) -> None:
     assert testcase.old_cwd is not None, "test was not properly set up"
     python = sys.executable
 
-    if sys.version_info < (3, 8) and testcase.location[-1] == "testTypedPkgSimpleEditable":
-        # Python 3.7 doesn't ship with new enough pip to support PEP 660
-        # This is a quick hack to skip the test; we'll drop Python 3.7 support soon enough
-        return
-
     assert python is not None, "Should be impossible"
     pkgs, pip_args = parse_pkgs(testcase.input[0])
     mypy_args = parse_mypy_args(testcase.input[1])
diff --git a/mypy/test/teststubgen.py b/mypy/test/teststubgen.py
index b21e06c0896af..884cf87ac5d8c 100644
--- a/mypy/test/teststubgen.py
+++ b/mypy/test/teststubgen.py
@@ -677,6 +677,7 @@ class StubgenPythonSuite(DataSuite):
     base_path = "."
     files = ["stubgen.test"]
 
+    @unittest.skipIf(sys.platform == "win32", "clean up fails on Windows")
     def run_case(self, testcase: DataDrivenTestCase) -> None:
         with local_sys_path_set():
             self.run_case_inner(testcase)
diff --git a/mypy/test/teststubtest.py b/mypy/test/teststubtest.py
index 275b09c3a240e..661d46e9fd8af 100644
--- a/mypy/test/teststubtest.py
+++ b/mypy/test/teststubtest.py
@@ -232,17 +232,16 @@ def test_arg_name(self) -> Iterator[Case]:
             runtime="def bad(num, text) -> None: pass",
             error="bad",
         )
-        if sys.version_info >= (3, 8):
-            yield Case(
-                stub="def good_posonly(__number: int, text: str) -> None: ...",
-                runtime="def good_posonly(num, /, text): pass",
-                error=None,
-            )
-            yield Case(
-                stub="def bad_posonly(__number: int, text: str) -> None: ...",
-                runtime="def bad_posonly(flag, /, text): pass",
-                error="bad_posonly",
-            )
+        yield Case(
+            stub="def good_posonly(__number: int, text: str) -> None: ...",
+            runtime="def good_posonly(num, /, text): pass",
+            error=None,
+        )
+        yield Case(
+            stub="def bad_posonly(__number: int, text: str) -> None: ...",
+            runtime="def bad_posonly(flag, /, text): pass",
+            error="bad_posonly",
+        )
         yield Case(
             stub="""
             class BadMethod:
@@ -283,22 +282,21 @@ def test_arg_kind(self) -> Iterator[Case]:
             runtime="def stub_posonly(number, text): pass",
             error="stub_posonly",
         )
-        if sys.version_info >= (3, 8):
-            yield Case(
-                stub="def good_posonly(__number: int, text: str) -> None: ...",
-                runtime="def good_posonly(number, /, text): pass",
-                error=None,
-            )
-            yield Case(
-                stub="def runtime_posonly(number: int, text: str) -> None: ...",
-                runtime="def runtime_posonly(number, /, text): pass",
-                error="runtime_posonly",
-            )
-            yield Case(
-                stub="def stub_posonly_570(number: int, /, text: str) -> None: ...",
-                runtime="def stub_posonly_570(number, text): pass",
-                error="stub_posonly_570",
-            )
+        yield Case(
+            stub="def good_posonly(__number: int, text: str) -> None: ...",
+            runtime="def good_posonly(number, /, text): pass",
+            error=None,
+        )
+        yield Case(
+            stub="def runtime_posonly(number: int, text: str) -> None: ...",
+            runtime="def runtime_posonly(number, /, text): pass",
+            error="runtime_posonly",
+        )
+        yield Case(
+            stub="def stub_posonly_570(number: int, /, text: str) -> None: ...",
+            runtime="def stub_posonly_570(number, text): pass",
+            error="stub_posonly_570",
+        )
 
     @collect_cases
     def test_default_presence(self) -> Iterator[Case]:
@@ -582,17 +580,16 @@ def f4(a: str, *args, b: int, **kwargs) -> str: ...
             runtime="def f4(a, *args, b, **kwargs): pass",
             error=None,
         )
-        if sys.version_info >= (3, 8):
-            yield Case(
-                stub="""
-                @overload
-                def f5(__a: int) -> int: ...
-                @overload
-                def f5(__b: str) -> str: ...
-                """,
-                runtime="def f5(x, /): pass",
-                error=None,
-            )
+        yield Case(
+            stub="""
+            @overload
+            def f5(__a: int) -> int: ...
+            @overload
+            def f5(__b: str) -> str: ...
+            """,
+            runtime="def f5(x, /): pass",
+            error=None,
+        )
 
     @collect_cases
     def test_property(self) -> Iterator[Case]:
diff --git a/mypy/util.py b/mypy/util.py
index 2c225c7fe6510..2960818d0984a 100644
--- a/mypy/util.py
+++ b/mypy/util.py
@@ -421,10 +421,10 @@ def get_unique_redefinition_name(name: str, existing: Container[str]) -> str:
 def check_python_version(program: str) -> None:
     """Report issues with the Python used to run mypy, dmypy, or stubgen"""
     # Check for known bad Python versions.
-    if sys.version_info[:2] < (3, 7):
+    if sys.version_info[:2] < (3, 8):
         sys.exit(
-            "Running {name} with Python 3.6 or lower is not supported; "
-            "please upgrade to 3.7 or newer".format(name=program)
+            "Running {name} with Python 3.7 or lower is not supported; "
+            "please upgrade to 3.8 or newer".format(name=program)
         )
 
 
diff --git a/mypy_self_check.ini b/mypy_self_check.ini
index 62083d1446214..7413e6407d4fd 100644
--- a/mypy_self_check.ini
+++ b/mypy_self_check.ini
@@ -6,7 +6,7 @@ show_traceback = True
 pretty = True
 always_false = MYPYC
 plugins = misc/proper_plugin.py
-python_version = 3.7
+python_version = 3.8
 exclude = mypy/typeshed/|mypyc/test-data/|mypyc/lib-rt/
 enable_error_code = ignore-without-code,redundant-expr
 show_error_code_links = True
diff --git a/mypyc/test/test_run.py b/mypyc/test/test_run.py
index a4071b9c3de53..2dd1c025123f8 100644
--- a/mypyc/test/test_run.py
+++ b/mypyc/test/test_run.py
@@ -64,12 +64,10 @@
     "run-dunders.test",
     "run-singledispatch.test",
     "run-attrs.test",
+    "run-python37.test",
+    "run-python38.test",
 ]
 
-files.append("run-python37.test")
-if sys.version_info >= (3, 8):
-    files.append("run-python38.test")
-
 if sys.version_info >= (3, 10):
     files.append("run-match.test")
 
diff --git a/pyproject.toml b/pyproject.toml
index 96a05d545946a..0f2712be52dd5 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -6,15 +6,12 @@ requires = [
     "setuptools >= 40.6.2",
     "wheel >= 0.30.0",
     # the following is from mypy-requirements.txt
-    "typing_extensions>=4.1.0; python_version >= '3.8'",
-    "typing_extensions>=4.7.0; python_version < '3.8'",
+    "typing_extensions>=4.1.0",
     "mypy_extensions>=1.0.0",
-    "typed_ast>=1.4.0,<2; python_version<'3.8'",
     "tomli>=1.1.0; python_version<'3.11'",
     # the following is from build-requirements.txt
     "types-psutil",
     "types-setuptools",
-    "types-typed-ast>=1.5.8.5,<1.6.0",
 ]
 build-backend = "setuptools.build_meta"
 
diff --git a/setup.py b/setup.py
index 85d412540013e..bbb655ea45371 100644
--- a/setup.py
+++ b/setup.py
@@ -8,8 +8,8 @@
 import sys
 from typing import TYPE_CHECKING, Any
 
-if sys.version_info < (3, 7, 0):
-    sys.stderr.write("ERROR: You need Python 3.7 or later to use mypy.\n")
+if sys.version_info < (3, 8, 0):
+    sys.stderr.write("ERROR: You need Python 3.8 or later to use mypy.\n")
     exit(1)
 
 # we'll import stuff from the source tree, let's ensure is on the sys path
@@ -186,7 +186,6 @@ def run(self):
     "Intended Audience :: Developers",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.7",
     "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
@@ -221,20 +220,18 @@ def run(self):
     cmdclass=cmdclass,
     # When changing this, also update mypy-requirements.txt.
     install_requires=[
-        "typed_ast >= 1.4.0, < 2; python_version<'3.8'",
-        "typing_extensions>=4.1.0; python_version >= '3.8'",
-        "typing_extensions>=4.7.0; python_version < '3.8'",
+        "typing_extensions>=4.1.0",
         "mypy_extensions >= 1.0.0",
         "tomli>=1.1.0; python_version<'3.11'",
     ],
     # Same here.
     extras_require={
         "dmypy": "psutil >= 4.0",
-        "python2": "typed_ast >= 1.4.0, < 2",
+        "python2": "",
         "reports": "lxml",
         "install-types": "pip",
     },
-    python_requires=">=3.7",
+    python_requires=">=3.8",
     include_package_data=True,
     project_urls={
         "News": "https://mypy-lang.org/news.html",
diff --git a/test-data/unit/check-columns.test b/test-data/unit/check-columns.test
index 7d1114ceab7a6..9d9a7d9ac039d 100644
--- a/test-data/unit/check-columns.test
+++ b/test-data/unit/check-columns.test
@@ -386,10 +386,6 @@ f(g(
 ))
 x[0]
 [out]
-main:2:10:2:10: error: Incompatible types in assignment (expression has type "str", variable has type "int")
-main:6:3:6:3: error: Argument 1 to "f" has incompatible type "int"; expected "str"
-main:8:1:8:1: error: Value of type "int" is not indexable
-[out version>=3.8]
 main:2:10:2:17: error: Incompatible types in assignment (expression has type "str", variable has type "int")
 main:6:3:7:1: error: Argument 1 to "f" has incompatible type "int"; expected "str"
 main:8:1:8:4: error: Value of type "int" is not indexable
diff --git a/test-data/unit/check-incremental.test b/test-data/unit/check-incremental.test
index 661afca807f40..c3153cd8643aa 100644
--- a/test-data/unit/check-incremental.test
+++ b/test-data/unit/check-incremental.test
@@ -3740,7 +3740,7 @@ import b
 [file b.py]
 -- This is a heinous hack, but we simulate having a invalid cache by clobbering
 -- the proto deps file with something with mtime mismatches.
-[file ../.mypy_cache/3.7/@deps.meta.json.2]
+[file ../.mypy_cache/3.8/@deps.meta.json.2]
 {"snapshot": {"__main__": "a7c958b001a45bd6a2a320f4e53c4c16", "a": "d41d8cd98f00b204e9800998ecf8427e", "b": "d41d8cd98f00b204e9800998ecf8427e", "builtins": "c532c89da517a4b779bcf7a964478d67"}, "deps_meta": {"@root": {"path": "@root.deps.json", "mtime": 0}, "__main__": {"path": "__main__.deps.json", "mtime": 0}, "a": {"path": "a.deps.json", "mtime": 0}, "b": {"path": "b.deps.json", "mtime": 0}, "builtins": {"path": "builtins.deps.json", "mtime": 0}}}
 [file ../.mypy_cache/.gitignore]
 # Another hack to not trigger a .gitignore creation failure "false positive"
@@ -3775,7 +3775,7 @@ import b
 [file b.py]
 -- This is a heinous hack, but we simulate having a invalid cache by deleting
 -- the proto deps file.
-[delete ../.mypy_cache/3.7/@deps.meta.json.2]
+[delete ../.mypy_cache/3.8/@deps.meta.json.2]
 [file b.py.2]
 # uh
 -- Every file should get reloaded, since the cache was invalidated
diff --git a/test-data/unit/check-parameter-specification.test b/test-data/unit/check-parameter-specification.test
index bebbbf4b16767..3d05faed74f17 100644
--- a/test-data/unit/check-parameter-specification.test
+++ b/test-data/unit/check-parameter-specification.test
@@ -592,8 +592,6 @@ def f2(c: Callable[P, R]) -> Callable[Concatenate[int, P], R]:
 f2(lambda x: 42)(42, x=42)
 [builtins fixtures/paramspec.pyi]
 [out]
-main:10: error: invalid syntax; you likely need to run mypy using Python 3.8 or newer
-[out version>=3.8]
 main:17: error: Incompatible return value type (got "Callable[[Arg(int, 'x'), **P], R]", expected "Callable[[int, **P], R]")
 main:17: note: This is likely because "result" has named arguments: "x". Consider marking them positional-only
 
@@ -620,9 +618,6 @@ def f2(c: Callable[P, R]) -> Callable[Concatenate[int, P], R]:
 # reason for rejection:
 f2(lambda x: 42)(42, x=42)
 [builtins fixtures/paramspec.pyi]
-[out]
-main:11: error: invalid syntax; you likely need to run mypy using Python 3.8 or newer
-[out version>=3.8]
 
 [case testParamSpecConcatenateWithTypeVar]
 from typing_extensions import ParamSpec, Concatenate
@@ -662,8 +657,6 @@ reveal_type(abc)
 bar(abc)
 [builtins fixtures/paramspec.pyi]
 [out]
-main:13: error: invalid syntax; you likely need to run mypy using Python 3.8 or newer
-[out version>=3.8]
 main:16: note: Revealed type is "__main__.Foo[[builtins.int, b: builtins.str]]"
 
 [case testSolveParamSpecWithSelfType]
diff --git a/test-data/unit/check-typeguard.test b/test-data/unit/check-typeguard.test
index b4c0071489033..a307e4c8b6a06 100644
--- a/test-data/unit/check-typeguard.test
+++ b/test-data/unit/check-typeguard.test
@@ -620,10 +620,6 @@ def bad_typeguard(*, x: object) -> TypeGuard[int]: # line 15
 [builtins fixtures/classmethod.pyi]
 [out]
 main:4: error: TypeGuard functions must have a positional argument
-main:11: error: TypeGuard functions must have a positional argument
-main:15: error: TypeGuard functions must have a positional argument
-[out version>=3.8]
-main:4: error: TypeGuard functions must have a positional argument
 main:12: error: TypeGuard functions must have a positional argument
 main:15: error: TypeGuard functions must have a positional argument
 
diff --git a/test-data/unit/cmdline.test b/test-data/unit/cmdline.test
index b87bb7f17eb0f..6e9fdf6dab654 100644
--- a/test-data/unit/cmdline.test
+++ b/test-data/unit/cmdline.test
@@ -1122,19 +1122,6 @@ class AnotherCustomClassDefinedBelow:
     def another_even_more_interesting_method(self, arg: Union[int, str, float]) -> None:
         self.very_important_attribute_with_long_name: OneCustomClassName = OneCustomClassName().some_interesting_method(arg)
 [out]
-some_file.py:3: error: Unsupported operand types for + ("int" and "str")
-    42 + 'no way'
-         ^
-some_file.py:11: error: Incompatible types in assignment (expression has type
-"AnotherCustomClassDefinedBelow", variable has type "OneCustomClassName")
-    ...t_attribute_with_long_name: OneCustomClassName = OneCustomClassName()....
-                                                        ^
-some_file.py:11: error: Argument 1 to "some_interesting_method" of
-"OneCustomClassName" has incompatible type "Union[int, str, float]"; expected
-"AnotherCustomClassDefinedBelow"
-    ...OneCustomClassName = OneCustomClassName().some_interesting_method(arg)
-                                                                         ^
-[out version>=3.8]
 some_file.py:3: error: Unsupported operand types for + ("int" and "str")
     42 + 'no way'
          ^~~~~~~~
@@ -1165,14 +1152,6 @@ def test_tabs() -> str:
 def test_between(x: str) -> None: ...
 test_between(1	+	1)
 [out]
-tabs.py:2: error: Incompatible return value type (got "None", expected "str")
-            return None
-                   ^
-tabs.py:4: error: Argument 1 to "test_between" has incompatible type "int";
-expected "str"
-    test_between(1  +       1)
-                 ^
-[out version>=3.8]
 tabs.py:2: error: Incompatible return value type (got "None", expected "str")
             return None
                    ^~~~
diff --git a/test-data/unit/daemon.test b/test-data/unit/daemon.test
index 1fae1514111c4..f208b4e78e54b 100644
--- a/test-data/unit/daemon.test
+++ b/test-data/unit/daemon.test
@@ -360,7 +360,7 @@ def bar() -> None:
     x = foo('abc')  # type: str
     foo(arg='xyz')
 
-[case testDaemonGetType_python38]
+[case testDaemonGetType]
 $ dmypy start --log-file log.txt -- --follow-imports=error --no-error-summary --python-version 3.8
 Daemon started
 $ dmypy inspect foo:1:2:3:4
@@ -423,7 +423,7 @@ def unreachable(x: int) -> None:
     return
     x  # line 17
 
-[case testDaemonGetTypeInexact_python38]
+[case testDaemonGetTypeInexact]
 $ dmypy start --log-file log.txt -- --follow-imports=error --no-error-summary
 Daemon started
 $ dmypy check foo.py --export-types
@@ -478,7 +478,7 @@ def unreachable(x: int, y: int) -> None:
     return
     x and y  # line 11
 
-[case testDaemonGetAttrs_python38]
+[case testDaemonGetAttrs]
 $ dmypy start --log-file log.txt -- --follow-imports=error --no-error-summary
 Daemon started
 $ dmypy check foo.py bar.py --export-types
@@ -520,7 +520,7 @@ class B:
 var: Union[A, B]
 var  # line 10
 
-[case testDaemonGetDefinition_python38]
+[case testDaemonGetDefinition]
 $ dmypy start --log-file log.txt -- --follow-imports=error --no-error-summary
 Daemon started
 $ dmypy check foo.py bar/baz.py bar/__init__.py --export-types
diff --git a/test-data/unit/fine-grained-blockers.test b/test-data/unit/fine-grained-blockers.test
index a134fb1d43011..33dedd8871142 100644
--- a/test-data/unit/fine-grained-blockers.test
+++ b/test-data/unit/fine-grained-blockers.test
@@ -48,16 +48,6 @@ a.py:1: error: invalid syntax  [syntax]
     def f(x: int) ->
                     ^
 ==
-main:3: error: Missing positional argument "x" in call to "f"  [call-arg]
-    a.f()
-    ^
-==
-[out version>=3.8]
-==
-a.py:1: error: invalid syntax  [syntax]
-    def f(x: int) ->
-                    ^
-==
 main:3: error: Missing positional argument "x" in call to "f"  [call-arg]
     a.f()
     ^~~~~
diff --git a/test-data/unit/fine-grained-cache-incremental.test b/test-data/unit/fine-grained-cache-incremental.test
index 50f93dd35af34..00157333efd7e 100644
--- a/test-data/unit/fine-grained-cache-incremental.test
+++ b/test-data/unit/fine-grained-cache-incremental.test
@@ -202,7 +202,7 @@ a.py:8: note:     x: expected "int", got "str"
 [file b.py]
 -- This is a heinous hack, but we simulate having a invalid cache by clobbering
 -- the proto deps file with something with mtime mismatches.
-[file ../.mypy_cache/3.7/@deps.meta.json.2]
+[file ../.mypy_cache/3.8/@deps.meta.json.2]
 {"snapshot": {"__main__": "a7c958b001a45bd6a2a320f4e53c4c16", "a": "d41d8cd98f00b204e9800998ecf8427e", "b": "d41d8cd98f00b204e9800998ecf8427e", "builtins": "c532c89da517a4b779bcf7a964478d67"}, "deps_meta": {"@root": {"path": "@root.deps.json", "mtime": 0}, "__main__": {"path": "__main__.deps.json", "mtime": 0}, "a": {"path": "a.deps.json", "mtime": 0}, "b": {"path": "b.deps.json", "mtime": 0}, "builtins": {"path": "builtins.deps.json", "mtime": 0}}}
 
 [file b.py.2]
@@ -234,8 +234,8 @@ x = 10
 [file p/c.py]
 class C: pass
 
-[delete ../.mypy_cache/3.7/b.meta.json.2]
-[delete ../.mypy_cache/3.7/p/c.meta.json.2]
+[delete ../.mypy_cache/3.8/b.meta.json.2]
+[delete ../.mypy_cache/3.8/p/c.meta.json.2]
 
 [out]
 ==
diff --git a/test-data/unit/fine-grained.test b/test-data/unit/fine-grained.test
index a0d7d302fd08b..3cb234364a589 100644
--- a/test-data/unit/fine-grained.test
+++ b/test-data/unit/fine-grained.test
@@ -95,11 +95,6 @@ class A:
     def g(self, a: A) -> None: pass
 [out]
 ==
-main:5: error: Missing positional argument "a" in call to "g" of "A"  [call-arg]
-            a.g() # E
-            ^
-[out version>=3.8]
-==
 main:5: error: Missing positional argument "a" in call to "g" of "A"  [call-arg]
             a.g() # E
             ^~~~~
@@ -10101,23 +10096,6 @@ object + 1
 1()
 
 [out]
-b.py:1: error: Unsupported left operand type for + ("Type[object]")
-    object + 1
-    ^
-a.py:1: error: Unsupported operand types for + ("int" and "str")
-    1 + ''
-        ^
-==
-b.py:1: error: Unsupported left operand type for + ("Type[object]")
-    object + 1
-    ^
-b.py:2: error: "int" not callable
-    1()
-    ^
-a.py:1: error: Unsupported operand types for + ("int" and "str")
-    1 + ''
-        ^
-[out version>=3.8]
 b.py:1: error: Unsupported left operand type for + ("Type[object]")
     object + 1
     ^~~~~~~~~~
diff --git a/test-data/unit/pythoneval.test b/test-data/unit/pythoneval.test
index 1460002e1b656..e4eecc33871c2 100644
--- a/test-data/unit/pythoneval.test
+++ b/test-data/unit/pythoneval.test
@@ -1441,7 +1441,7 @@ accepts_named_tuple(b)
 accepts_named_tuple(1)
 accepts_named_tuple((1, 2))
 [out]
-_testNamedTupleTypeInheritanceSpecialCase.py:8: note: Revealed type is "collections.OrderedDict[builtins.str, Any]"
+_testNamedTupleTypeInheritanceSpecialCase.py:8: note: Revealed type is "builtins.dict[builtins.str, Any]"
 _testNamedTupleTypeInheritanceSpecialCase.py:9: note: Revealed type is "builtins.tuple[builtins.str, ...]"
 _testNamedTupleTypeInheritanceSpecialCase.py:10: note: Revealed type is "builtins.dict[builtins.str, Any]"
 _testNamedTupleTypeInheritanceSpecialCase.py:17: error: Argument 1 to "accepts_named_tuple" has incompatible type "int"; expected "NamedTuple"
diff --git a/test-data/unit/semanal-errors.test b/test-data/unit/semanal-errors.test
index 9c6ac2833c8bf..a098dd8791d48 100644
--- a/test-data/unit/semanal-errors.test
+++ b/test-data/unit/semanal-errors.test
@@ -361,8 +361,6 @@ main:2: error: "yield" outside function
 [case testInvalidLvalues1]
 1 = 1
 [out]
-main:1: error: can't assign to literal
-[out version>=3.8]
 main:1: error: cannot assign to literal
 [out version>=3.10]
 main:1: error: cannot assign to literal here. Maybe you meant '==' instead of '='?
@@ -370,8 +368,6 @@ main:1: error: cannot assign to literal here. Maybe you meant '==' instead of '=
 [case testInvalidLvalues2]
 (1) = 1
 [out]
-main:1: error: can't assign to literal
-[out version>=3.8]
 main:1: error: cannot assign to literal
 [out version>=3.10]
 main:1: error: cannot assign to literal here. Maybe you meant '==' instead of '='?
@@ -379,37 +375,27 @@ main:1: error: cannot assign to literal here. Maybe you meant '==' instead of '=
 [case testInvalidLvalues3]
 (1, 1) = 1
 [out]
-main:1: error: can't assign to literal
-[out version>=3.8]
 main:1: error: cannot assign to literal
 
 [case testInvalidLvalues4]
 [1, 1] = 1
 [out]
-main:1: error: can't assign to literal
-[out version>=3.8]
 main:1: error: cannot assign to literal
 
 [case testInvalidLvalues6]
 x = y = z = 1  # ok
 x, (y, 1) = 1
 [out]
-main:2: error: can't assign to literal
-[out version>=3.8]
 main:2: error: cannot assign to literal
 
 [case testInvalidLvalues7]
 x, [y, 1] = 1
 [out]
-main:1: error: can't assign to literal
-[out version>=3.8]
 main:1: error: cannot assign to literal
 
 [case testInvalidLvalues8]
 x, [y, [z, 1]] = 1
 [out]
-main:1: error: can't assign to literal
-[out version>=3.8]
 main:1: error: cannot assign to literal
 
 [case testInvalidLvalues9]
@@ -417,15 +403,11 @@ x, (y) = 1 # ok
 x, (y, (z, z)) = 1 # ok
 x, (y, (z, 1)) = 1
 [out]
-main:3: error: can't assign to literal
-[out version>=3.8]
 main:3: error: cannot assign to literal
 
 [case testInvalidLvalues10]
 x + x = 1
 [out]
-main:1: error: can't assign to operator
-[out version>=3.8]
 main:1: error: cannot assign to operator
 [out version>=3.10]
 main:1: error: cannot assign to expression here. Maybe you meant '==' instead of '='?
@@ -433,8 +415,6 @@ main:1: error: cannot assign to expression here. Maybe you meant '==' instead of
 [case testInvalidLvalues11]
 -x = 1
 [out]
-main:1: error: can't assign to operator
-[out version>=3.8]
 main:1: error: cannot assign to operator
 [out version>=3.10]
 main:1: error: cannot assign to expression here. Maybe you meant '==' instead of '='?
@@ -442,8 +422,6 @@ main:1: error: cannot assign to expression here. Maybe you meant '==' instead of
 [case testInvalidLvalues12]
 1.1 = 1
 [out]
-main:1: error: can't assign to literal
-[out version>=3.8]
 main:1: error: cannot assign to literal
 [out version>=3.10]
 main:1: error: cannot assign to literal here. Maybe you meant '==' instead of '='?
@@ -451,8 +429,6 @@ main:1: error: cannot assign to literal here. Maybe you meant '==' instead of '=
 [case testInvalidLvalues13]
 'x' = 1
 [out]
-main:1: error: can't assign to literal
-[out version>=3.8]
 main:1: error: cannot assign to literal
 [out version>=3.10]
 main:1: error: cannot assign to literal here. Maybe you meant '==' instead of '='?
@@ -460,8 +436,6 @@ main:1: error: cannot assign to literal here. Maybe you meant '==' instead of '=
 [case testInvalidLvalues14]
 x() = 1
 [out]
-main:1: error: can't assign to function call
-[out version>=3.8]
 main:1: error: cannot assign to function call
 [out version>=3.10]
 main:1: error: cannot assign to function call here. Maybe you meant '==' instead of '='?
@@ -518,16 +492,12 @@ main:2: error: Can use starred expression only as assignment target
 x = 1
 del x(1)
 [out]
-main:2: error: can't delete function call
-[out version>=3.8]
 main:2: error: cannot delete function call
 
 [case testInvalidDel2]
 x = 1
 del x + 1
 [out]
-main:2: error: can't delete operator
-[out version>=3.8]
 main:2: error: cannot delete operator
 [out version>=3.10]
 main:2: error: cannot delete expression
@@ -927,8 +897,6 @@ import typing
 def f(): pass
 f() = 1 # type: int
 [out]
-main:3: error: can't assign to function call
-[out version>=3.8]
 main:3: error: cannot assign to function call
 [out version>=3.10]
 main:3: error: cannot assign to function call here. Maybe you meant '==' instead of '='?
@@ -1007,8 +975,6 @@ x, y = 1, 2 # type: int # E: Tuple type expected for multiple variables
 a = 1
 a() = None # type: int
 [out]
-main:2: error: can't assign to function call
-[out version>=3.8]
 main:2: error: cannot assign to function call
 [out version>=3.10]
 main:2: error: cannot assign to function call here. Maybe you meant '==' instead of '='?
@@ -1311,8 +1277,6 @@ main:2: note: Did you forget to import it from "typing"? (Suggestion: "from typi
 def f(): pass
 with f() as 1: pass
 [out]
-main:2: error: can't assign to literal
-[out version>=3.8]
 main:2: error: cannot assign to literal
 
 [case testInvalidTypeAnnotation]
@@ -1327,8 +1291,6 @@ import typing
 def f() -> None:
     f() = 1  # type: int
 [out]
-main:3: error: can't assign to function call
-[out version>=3.8]
 main:3: error: cannot assign to function call
 [out version>=3.10]
 main:3: error: cannot assign to function call here. Maybe you meant '==' instead of '='?
diff --git a/test-data/unit/semanal-statements.test b/test-data/unit/semanal-statements.test
index 9b43a5b853c0c..c143805f4564d 100644
--- a/test-data/unit/semanal-statements.test
+++ b/test-data/unit/semanal-statements.test
@@ -557,8 +557,6 @@ MypyFile:1(
 def f(x, y) -> None:
     del x, y + 1
 [out]
-main:2: error: can't delete operator
-[out version>=3.8]
 main:2: error: cannot delete operator
 [out version>=3.10]
 main:2: error: cannot delete expression

From 96eadfd29ab30517e8a2d44361bd6292d29284f4 Mon Sep 17 00:00:00 2001
From: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
Date: Sun, 2 Jul 2023 19:46:00 -0700
Subject: [PATCH 094/129] Fix wheel build trigger (#15568)

---
 .github/workflows/build_wheels.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/build_wheels.yml b/.github/workflows/build_wheels.yml
index da140375d603b..e728d741d90d7 100644
--- a/.github/workflows/build_wheels.yml
+++ b/.github/workflows/build_wheels.yml
@@ -13,7 +13,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-python@v4
         with:
-          python-version: '3.7'
+          python-version: '3.11'
       - name: Trigger script
         env:
           WHEELS_PUSH_TOKEN: ${{ secrets.WHEELS_PUSH_TOKEN }}

From 259c822938c4d3461ba80e8162faf082d487162a Mon Sep 17 00:00:00 2001
From: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
Date: Sun, 2 Jul 2023 20:30:38 -0700
Subject: [PATCH 095/129] Unskip some tests that appear to pass (#15567)

These mostly date back to https://github.com/python/mypy/pull/4369 There
are also some skipped tests in here that fail that I don't touch
---
 mypy/test/testsubtypes.py | 3 +--
 mypy/test/testtypes.py    | 3 ---
 2 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/mypy/test/testsubtypes.py b/mypy/test/testsubtypes.py
index c76a34ff00d7f..464f64d2b846d 100644
--- a/mypy/test/testsubtypes.py
+++ b/mypy/test/testsubtypes.py
@@ -2,7 +2,7 @@
 
 from mypy.nodes import CONTRAVARIANT, COVARIANT, INVARIANT
 from mypy.subtypes import is_subtype
-from mypy.test.helpers import Suite, skip
+from mypy.test.helpers import Suite
 from mypy.test.typefixture import InterfaceTypeFixture, TypeFixture
 from mypy.types import Instance, TupleType, Type, UnpackType
 
@@ -69,7 +69,6 @@ def test_interface_subtyping(self) -> None:
         self.assert_equivalent(self.fx.f, self.fx.f)
         self.assert_not_subtype(self.fx.a, self.fx.f)
 
-    @skip
     def test_generic_interface_subtyping(self) -> None:
         # TODO make this work
         fx2 = InterfaceTypeFixture()
diff --git a/mypy/test/testtypes.py b/mypy/test/testtypes.py
index 5f6943de3199d..246350dc02cdc 100644
--- a/mypy/test/testtypes.py
+++ b/mypy/test/testtypes.py
@@ -899,13 +899,11 @@ def ov(*items: CallableType) -> Overloaded:
         self.assert_join(ov(c(fx.a, fx.a), c(fx.b, fx.b)), c(any, fx.b), c(any, fx.b))
         self.assert_join(ov(c(fx.a, fx.a), c(any, fx.b)), c(fx.b, fx.b), c(any, fx.b))
 
-    @skip
     def test_join_interface_types(self) -> None:
         self.assert_join(self.fx.f, self.fx.f, self.fx.f)
         self.assert_join(self.fx.f, self.fx.f2, self.fx.o)
         self.assert_join(self.fx.f, self.fx.f3, self.fx.f)
 
-    @skip
     def test_join_interface_and_class_types(self) -> None:
         self.assert_join(self.fx.o, self.fx.f, self.fx.o)
         self.assert_join(self.fx.a, self.fx.f, self.fx.o)
@@ -1180,7 +1178,6 @@ def test_meet_class_types_with_shared_interfaces(self) -> None:
         self.assert_meet(self.fx.e, self.fx.e2, self.fx.nonet)
         self.assert_meet(self.fx.e2, self.fx.e3, self.fx.nonet)
 
-    @skip
     def test_meet_with_generic_interfaces(self) -> None:
         fx = InterfaceTypeFixture()
         self.assert_meet(fx.gfa, fx.m1, fx.m1)

From a759c490d21bb9d73e788da4a8dc5c10b077a482 Mon Sep 17 00:00:00 2001
From: Nikita Sobolev <mail@sobolevn.me>
Date: Mon, 3 Jul 2023 20:05:49 +0300
Subject: [PATCH 096/129] Fix `ast` warnings for Python3.12 (#15558)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Warnings before:
https://github.com/python/mypy/issues/15330#issuecomment-1615010604
Warnings after:

```
(.venv312) ~/Desktop/mypy  master ✗
» python -m mypy ex.py
Success: no issues found in 1 source file
```

Zero :)

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
---
 mypy/fastparse.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/mypy/fastparse.py b/mypy/fastparse.py
index 3f4e2f4c927d1..fa185be21f9e3 100644
--- a/mypy/fastparse.py
+++ b/mypy/fastparse.py
@@ -1873,7 +1873,6 @@ def visit_BinOp(self, n: ast3.BinOp) -> Type:
             uses_pep604_syntax=True,
         )
 
-    # Only for 3.8 and newer
     def visit_Constant(self, n: Constant) -> Type:
         val = n.value
         if val is None:
@@ -1881,7 +1880,7 @@ def visit_Constant(self, n: Constant) -> Type:
             return UnboundType("None", line=self.line)
         if isinstance(val, str):
             # Parse forward reference.
-            return parse_type_string(n.s, "builtins.str", self.line, n.col_offset)
+            return parse_type_string(val, "builtins.str", self.line, n.col_offset)
         if val is Ellipsis:
             # '...' is valid in some types.
             return EllipsisType(line=self.line)

From 4df2215981593d14faf25e3dec658fffeed9c41f Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Mon, 3 Jul 2023 20:06:23 +0100
Subject: [PATCH 097/129] [mypyc] Fix 3.12 issue with pickling of instances
 with __dict__ (#15574)

This fixes the testPickling test case in
mypyc/test-data/run-classes.test on Python 3.12.

Handle another case that was missed in #15471. On 3.12 we rely on
Py_TPFLAGS_MANAGED_DICT and shouldn't define an explicit `__dict__`
member.

Work on mypyc/mypyc#995.
---
 mypyc/codegen/emitclass.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mypyc/codegen/emitclass.py b/mypyc/codegen/emitclass.py
index 3606f5267a8a7..84d19d69d3778 100644
--- a/mypyc/codegen/emitclass.py
+++ b/mypyc/codegen/emitclass.py
@@ -270,7 +270,7 @@ def emit_line() -> None:
     # that isn't what we want.
 
     # XXX: there is no reason for the __weakref__ stuff to be mixed up with __dict__
-    if cl.has_dict:
+    if cl.has_dict and not has_managed_dict(cl, emitter):
         # __dict__ lives right after the struct and __weakref__ lives right after that
         # TODO: They should get members in the struct instead of doing this nonsense.
         weak_offset = f"{base_size} + sizeof(PyObject *)"

From 2e9c9b4ec9eece1209c6df1e559ed371cdfbd1b3 Mon Sep 17 00:00:00 2001
From: Nikita Sobolev <mail@sobolevn.me>
Date: Mon, 3 Jul 2023 22:07:10 +0300
Subject: [PATCH 098/129] Solve import cycles in expandtype and testtypes.py
 (#15580)

---
 mypy/expandtype.py     | 6 ++++--
 mypy/test/testtypes.py | 7 ++++---
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/mypy/expandtype.py b/mypy/expandtype.py
index 5bbdd5311da7f..24835a5ee4d6f 100644
--- a/mypy/expandtype.py
+++ b/mypy/expandtype.py
@@ -5,7 +5,6 @@
 
 from mypy.nodes import ARG_POS, ARG_STAR, ArgKind, Var
 from mypy.state import state
-from mypy.type_visitor import TypeTranslator
 from mypy.types import (
     ANY_STRATEGY,
     AnyType,
@@ -44,6 +43,9 @@
 )
 from mypy.typevartuples import find_unpack_in_list, split_with_instance
 
+# Solving the import cycle:
+import mypy.type_visitor  # ruff: isort: skip
+
 # WARNING: these functions should never (directly or indirectly) depend on
 # is_subtype(), meet_types(), join_types() etc.
 # TODO: add a static dependency test for this.
@@ -167,7 +169,7 @@ def freshen_all_functions_type_vars(t: T) -> T:
         return result
 
 
-class FreshenCallableVisitor(TypeTranslator):
+class FreshenCallableVisitor(mypy.type_visitor.TypeTranslator):
     def visit_callable_type(self, t: CallableType) -> Type:
         result = super().visit_callable_type(t)
         assert isinstance(result, ProperType) and isinstance(result, CallableType)
diff --git a/mypy/test/testtypes.py b/mypy/test/testtypes.py
index 246350dc02cdc..b1f21b3be79bd 100644
--- a/mypy/test/testtypes.py
+++ b/mypy/test/testtypes.py
@@ -5,9 +5,7 @@
 import re
 from unittest import TestCase, skipUnless
 
-import mypy.expandtype
 from mypy.erasetype import erase_type, remove_instance_last_known_values
-from mypy.expandtype import expand_type
 from mypy.indirection import TypeIndirectionVisitor
 from mypy.join import join_simple, join_types
 from mypy.meet import meet_types, narrow_declared_type
@@ -53,6 +51,9 @@
     has_recursive_types,
 )
 
+# Solving the import cycle:
+import mypy.expandtype  # ruff: isort: skip
+
 
 class TypesSuite(Suite):
     def setUp(self) -> None:
@@ -268,7 +269,7 @@ def assert_expand(
         for id, t in map_items:
             lower_bounds[id] = t
 
-        exp = expand_type(orig, lower_bounds)
+        exp = mypy.expandtype.expand_type(orig, lower_bounds)
         # Remove erased tags (asterisks).
         assert_equal(str(exp).replace("*", ""), str(result))
 

From 5e4d097a1801bcc6f4c160f99cd1ee95f24768aa Mon Sep 17 00:00:00 2001
From: Ivan Levkivskyi <levkivskyi@gmail.com>
Date: Mon, 3 Jul 2023 20:20:48 +0100
Subject: [PATCH 099/129] Fix strict optional handling in dataclasses (#15571)

There were few cases when someone forgot to call `strict_optional_set()`
in dataclasses plugin, let's move the calls directly to two places where
they are needed for typeops. This may cause a tiny perf regression, but
is much more robust in terms of preventing bugs.
---
 mypy/plugins/dataclasses.py    | 30 +++++++++++++++++-------------
 test-data/unit/pythoneval.test | 18 +++++++++++++++---
 2 files changed, 32 insertions(+), 16 deletions(-)

diff --git a/mypy/plugins/dataclasses.py b/mypy/plugins/dataclasses.py
index 9e054493828f2..efa1338962a05 100644
--- a/mypy/plugins/dataclasses.py
+++ b/mypy/plugins/dataclasses.py
@@ -104,6 +104,7 @@ def __init__(
         info: TypeInfo,
         kw_only: bool,
         is_neither_frozen_nor_nonfrozen: bool,
+        api: SemanticAnalyzerPluginInterface,
     ) -> None:
         self.name = name
         self.alias = alias
@@ -116,6 +117,7 @@ def __init__(
         self.info = info
         self.kw_only = kw_only
         self.is_neither_frozen_nor_nonfrozen = is_neither_frozen_nor_nonfrozen
+        self._api = api
 
     def to_argument(self, current_info: TypeInfo) -> Argument:
         arg_kind = ARG_POS
@@ -138,7 +140,10 @@ def expand_type(self, current_info: TypeInfo) -> Optional[Type]:
             # however this plugin is called very late, so all types should be fully ready.
             # Also, it is tricky to avoid eager expansion of Self types here (e.g. because
             # we serialize attributes).
-            return expand_type(self.type, {self.info.self_type.id: fill_typevars(current_info)})
+            with state.strict_optional_set(self._api.options.strict_optional):
+                return expand_type(
+                    self.type, {self.info.self_type.id: fill_typevars(current_info)}
+                )
         return self.type
 
     def to_var(self, current_info: TypeInfo) -> Var:
@@ -165,13 +170,14 @@ def deserialize(
     ) -> DataclassAttribute:
         data = data.copy()
         typ = deserialize_and_fixup_type(data.pop("type"), api)
-        return cls(type=typ, info=info, **data)
+        return cls(type=typ, info=info, **data, api=api)
 
     def expand_typevar_from_subtype(self, sub_type: TypeInfo) -> None:
         """Expands type vars in the context of a subtype when an attribute is inherited
         from a generic super type."""
         if self.type is not None:
-            self.type = map_type_from_supertype(self.type, sub_type, self.info)
+            with state.strict_optional_set(self._api.options.strict_optional):
+                self.type = map_type_from_supertype(self.type, sub_type, self.info)
 
 
 class DataclassTransformer:
@@ -230,12 +236,11 @@ def transform(self) -> bool:
             and ("__init__" not in info.names or info.names["__init__"].plugin_generated)
             and attributes
         ):
-            with state.strict_optional_set(self._api.options.strict_optional):
-                args = [
-                    attr.to_argument(info)
-                    for attr in attributes
-                    if attr.is_in_init and not self._is_kw_only_type(attr.type)
-                ]
+            args = [
+                attr.to_argument(info)
+                for attr in attributes
+                if attr.is_in_init and not self._is_kw_only_type(attr.type)
+            ]
 
             if info.fallback_to_any:
                 # Make positional args optional since we don't know their order.
@@ -355,8 +360,7 @@ def transform(self) -> bool:
         self._add_dataclass_fields_magic_attribute()
 
         if self._spec is _TRANSFORM_SPEC_FOR_DATACLASSES:
-            with state.strict_optional_set(self._api.options.strict_optional):
-                self._add_internal_replace_method(attributes)
+            self._add_internal_replace_method(attributes)
         if "__post_init__" in info.names:
             self._add_internal_post_init_method(attributes)
 
@@ -546,8 +550,7 @@ def collect_attributes(self) -> list[DataclassAttribute] | None:
                 # TODO: We shouldn't be performing type operations during the main
                 #       semantic analysis pass, since some TypeInfo attributes might
                 #       still be in flux. This should be performed in a later phase.
-                with state.strict_optional_set(self._api.options.strict_optional):
-                    attr.expand_typevar_from_subtype(cls.info)
+                attr.expand_typevar_from_subtype(cls.info)
                 found_attrs[name] = attr
 
                 sym_node = cls.info.names.get(name)
@@ -693,6 +696,7 @@ def collect_attributes(self) -> list[DataclassAttribute] | None:
                 is_neither_frozen_nor_nonfrozen=_has_direct_dataclass_transform_metaclass(
                     cls.info
                 ),
+                api=self._api,
             )
 
         all_attrs = list(found_attrs.values())
diff --git a/test-data/unit/pythoneval.test b/test-data/unit/pythoneval.test
index e4eecc33871c2..abc0f6a464a90 100644
--- a/test-data/unit/pythoneval.test
+++ b/test-data/unit/pythoneval.test
@@ -2094,7 +2094,6 @@ grouped = groupby(pairs, key=fst)
 [out]
 
 [case testDataclassReplaceOptional]
-# flags: --strict-optional
 from dataclasses import dataclass, replace
 from typing import Optional
 
@@ -2107,5 +2106,18 @@ reveal_type(a)
 a2 = replace(a, x=None)  # OK
 reveal_type(a2)
 [out]
-_testDataclassReplaceOptional.py:10: note: Revealed type is "_testDataclassReplaceOptional.A"
-_testDataclassReplaceOptional.py:12: note: Revealed type is "_testDataclassReplaceOptional.A"
+_testDataclassReplaceOptional.py:9: note: Revealed type is "_testDataclassReplaceOptional.A"
+_testDataclassReplaceOptional.py:11: note: Revealed type is "_testDataclassReplaceOptional.A"
+
+[case testDataclassStrictOptionalAlwaysSet]
+from dataclasses import dataclass
+from typing import Callable, Optional
+
+@dataclass
+class Description:
+    name_fn: Callable[[Optional[int]], Optional[str]]
+
+def f(d: Description) -> None:
+    reveal_type(d.name_fn)
+[out]
+_testDataclassStrictOptionalAlwaysSet.py:9: note: Revealed type is "def (Union[builtins.int, None]) -> Union[builtins.str, None]"

From 49d95cf6b40fb3ebee2183e95206c91c81e7a107 Mon Sep 17 00:00:00 2001
From: Alex Waygood <Alex.Waygood@Gmail.com>
Date: Mon, 3 Jul 2023 20:37:03 +0100
Subject: [PATCH 100/129] Don't add fictional parameters to
 `NamedTuple._make()` (#15578)

---
 mypy/semanal_namedtuple.py           | 7 +------
 test-data/unit/check-newsemanal.test | 4 ++--
 2 files changed, 3 insertions(+), 8 deletions(-)

diff --git a/mypy/semanal_namedtuple.py b/mypy/semanal_namedtuple.py
index c690d4ec6d20f..5eac02833d24c 100644
--- a/mypy/semanal_namedtuple.py
+++ b/mypy/semanal_namedtuple.py
@@ -605,16 +605,11 @@ def make_init_arg(var: Var) -> Argument:
 
         add_method("__new__", ret=selftype, args=[make_init_arg(var) for var in vars], is_new=True)
         add_method("_asdict", args=[], ret=ordereddictype)
-        special_form_any = AnyType(TypeOfAny.special_form)
         add_method(
             "_make",
             ret=selftype,
             is_classmethod=True,
-            args=[
-                Argument(Var("iterable", iterable_type), iterable_type, None, ARG_POS),
-                Argument(Var("new"), special_form_any, EllipsisExpr(), ARG_NAMED_OPT),
-                Argument(Var("len"), special_form_any, EllipsisExpr(), ARG_NAMED_OPT),
-            ],
+            args=[Argument(Var("iterable", iterable_type), iterable_type, None, ARG_POS)],
         )
 
         self_tvar_expr = TypeVarExpr(
diff --git a/test-data/unit/check-newsemanal.test b/test-data/unit/check-newsemanal.test
index 99f4141a4d649..de8212b3e6950 100644
--- a/test-data/unit/check-newsemanal.test
+++ b/test-data/unit/check-newsemanal.test
@@ -992,7 +992,7 @@ class SubO(Out): pass
 
 o: SubO
 
-reveal_type(SubO._make)  # N: Revealed type is "def (iterable: typing.Iterable[Any], *, new: Any =, len: Any =) -> Tuple[Tuple[builtins.str, __main__.Other, fallback=__main__.In], __main__.Other, fallback=__main__.SubO]"
+reveal_type(SubO._make)  # N: Revealed type is "def (iterable: typing.Iterable[Any]) -> Tuple[Tuple[builtins.str, __main__.Other, fallback=__main__.In], __main__.Other, fallback=__main__.SubO]"
 reveal_type(o._replace(y=Other()))  # N: Revealed type is "Tuple[Tuple[builtins.str, __main__.Other, fallback=__main__.In], __main__.Other, fallback=__main__.SubO]"
 [builtins fixtures/tuple.pyi]
 
@@ -1009,7 +1009,7 @@ o: Out
 reveal_type(o)  # N: Revealed type is "Tuple[Tuple[builtins.str, __main__.Other, fallback=__main__.In], __main__.Other, fallback=__main__.Out]"
 reveal_type(o.x)  # N: Revealed type is "Tuple[builtins.str, __main__.Other, fallback=__main__.In]"
 reveal_type(o.x.t)  # N: Revealed type is "__main__.Other"
-reveal_type(Out._make)  # N: Revealed type is "def (iterable: typing.Iterable[Any], *, new: Any =, len: Any =) -> Tuple[Tuple[builtins.str, __main__.Other, fallback=__main__.In], __main__.Other, fallback=__main__.Out]"
+reveal_type(Out._make)  # N: Revealed type is "def (iterable: typing.Iterable[Any]) -> Tuple[Tuple[builtins.str, __main__.Other, fallback=__main__.In], __main__.Other, fallback=__main__.Out]"
 [builtins fixtures/tuple.pyi]
 
 [case testNewAnalyzerIncompleteRefShadowsBuiltin1]

From dcdcc60b3082b99b0088e0f5c443f90a60091d77 Mon Sep 17 00:00:00 2001
From: Nikita Sobolev <mail@sobolevn.me>
Date: Mon, 3 Jul 2023 22:37:47 +0300
Subject: [PATCH 101/129] Run `pyupgrade --py38-plus` on the source code
 (#15575)

---
 misc/analyze_cache.py                 |  4 ++--
 misc/incremental_checker.py           |  4 ++--
 mypy/build.py                         |  3 ++-
 mypy/checker.py                       |  5 +++--
 mypy/checkexpr.py                     |  6 +++---
 mypy/checkpattern.py                  |  3 +--
 mypy/checkstrformat.py                |  4 ++--
 mypy/config_parser.py                 |  3 ++-
 mypy/constant_fold.py                 |  3 +--
 mypy/constraints.py                   |  3 +--
 mypy/defaults.py                      |  2 +-
 mypy/dmypy_server.py                  |  4 ++--
 mypy/dmypy_util.py                    |  3 +--
 mypy/errorcodes.py                    |  2 +-
 mypy/errors.py                        |  4 ++--
 mypy/evalexpr.py                      |  2 +-
 mypy/expandtype.py                    |  3 +--
 mypy/fastparse.py                     |  4 ++--
 mypy/find_sources.py                  |  5 ++---
 mypy/fixup.py                         |  3 +--
 mypy/ipc.py                           |  3 +--
 mypy/literals.py                      |  4 ++--
 mypy/main.py                          |  3 +--
 mypy/message_registry.py              |  3 +--
 mypy/messages.py                      |  3 +--
 mypy/modulefinder.py                  |  4 ++--
 mypy/nodes.py                         |  3 ++-
 mypy/operators.py                     |  2 +-
 mypy/options.py                       |  5 ++---
 mypy/plugins/attrs.py                 |  4 ++--
 mypy/plugins/dataclasses.py           |  5 ++---
 mypy/plugins/enums.py                 |  3 +--
 mypy/plugins/functools.py             |  3 +--
 mypy/plugins/singledispatch.py        |  4 ++--
 mypy/reachability.py                  |  3 +--
 mypy/renaming.py                      |  3 +--
 mypy/report.py                        |  4 ++--
 mypy/semanal.py                       |  4 ++--
 mypy/semanal_classprop.py             |  2 +-
 mypy/semanal_enum.py                  |  3 +--
 mypy/semanal_main.py                  |  4 ++--
 mypy/semanal_namedtuple.py            |  3 +--
 mypy/semanal_shared.py                |  4 ++--
 mypy/semanal_typeddict.py             |  2 +-
 mypy/server/mergecheck.py             |  2 +-
 mypy/server/objgraph.py               |  3 +--
 mypy/server/trigger.py                |  2 +-
 mypy/server/update.py                 |  4 ++--
 mypy/sharedparse.py                   |  2 +-
 mypy/state.py                         |  3 +--
 mypy/stats.py                         |  3 +--
 mypy/stubdoc.py                       |  4 ++--
 mypy/stubgen.py                       |  3 +--
 mypy/stubgenc.py                      |  5 ++---
 mypy/subtypes.py                      |  4 ++--
 mypy/test/data.py                     |  4 ++--
 mypy/type_visitor.py                  |  3 +--
 mypy/typeanal.py                      |  4 ++--
 mypy/types.py                         |  3 ++-
 mypy/typestate.py                     |  4 ++--
 mypy/util.py                          |  4 ++--
 mypyc/analysis/attrdefined.py         |  5 ++---
 mypyc/codegen/cstring.py              |  2 +-
 mypyc/codegen/emit.py                 |  5 ++---
 mypyc/codegen/emitfunc.py             |  8 ++++----
 mypyc/codegen/literals.py             |  6 +++---
 mypyc/common.py                       |  3 +--
 mypyc/ir/class_ir.py                  |  6 +++---
 mypyc/ir/func_ir.py                   |  5 ++---
 mypyc/ir/ops.py                       | 19 +++++++++----------
 mypyc/ir/pprint.py                    |  3 +--
 mypyc/ir/rtypes.py                    |  3 +--
 mypyc/irbuild/builder.py              |  4 ++--
 mypyc/irbuild/classdef.py             |  3 +--
 mypyc/irbuild/constant_fold.py        |  3 +--
 mypyc/irbuild/format_str_tokenizer.py |  2 +-
 mypyc/irbuild/ll_builder.py           |  3 +--
 mypyc/irbuild/specialize.py           |  2 +-
 mypyc/primitives/registry.py          | 13 ++++++-------
 mypyc/test-data/fixtures/testutil.py  |  2 +-
 80 files changed, 137 insertions(+), 168 deletions(-)

diff --git a/misc/analyze_cache.py b/misc/analyze_cache.py
index 45c44139b4734..33205f5132fc3 100644
--- a/misc/analyze_cache.py
+++ b/misc/analyze_cache.py
@@ -6,8 +6,8 @@
 import os
 import os.path
 from collections import Counter
-from typing import Any, Dict, Iterable
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from typing import Any, Dict, Final, Iterable
+from typing_extensions import TypeAlias as _TypeAlias
 
 ROOT: Final = ".mypy_cache/3.5"
 
diff --git a/misc/incremental_checker.py b/misc/incremental_checker.py
index 85239b6462b88..4e42aef333bb4 100755
--- a/misc/incremental_checker.py
+++ b/misc/incremental_checker.py
@@ -44,8 +44,8 @@
 import textwrap
 import time
 from argparse import ArgumentParser, Namespace, RawDescriptionHelpFormatter
-from typing import Any, Dict
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from typing import Any, Dict, Final
+from typing_extensions import TypeAlias as _TypeAlias
 
 CACHE_PATH: Final = ".incremental_checker_cache.json"
 MYPY_REPO_URL: Final = "https://github.com/python/mypy.git"
diff --git a/mypy/build.py b/mypy/build.py
index 5a6f8c00896e3..5a0a481ae1a2f 100644
--- a/mypy/build.py
+++ b/mypy/build.py
@@ -31,6 +31,7 @@
     Callable,
     ClassVar,
     Dict,
+    Final,
     Iterator,
     Mapping,
     NamedTuple,
@@ -38,7 +39,7 @@
     Sequence,
     TextIO,
 )
-from typing_extensions import Final, TypeAlias as _TypeAlias, TypedDict
+from typing_extensions import TypeAlias as _TypeAlias, TypedDict
 
 import mypy.semanal_main
 from mypy.checker import TypeChecker
diff --git a/mypy/checker.py b/mypy/checker.py
index cdce42ddaaa1f..bf200299d8b33 100644
--- a/mypy/checker.py
+++ b/mypy/checker.py
@@ -9,6 +9,7 @@
     AbstractSet,
     Callable,
     Dict,
+    Final,
     Generic,
     Iterable,
     Iterator,
@@ -22,7 +23,7 @@
     cast,
     overload,
 )
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from typing_extensions import TypeAlias as _TypeAlias
 
 import mypy.checkexpr
 from mypy import errorcodes as codes, message_registry, nodes, operators
@@ -1546,7 +1547,7 @@ def check_reverse_op_method(
                 if opt_meta is not None:
                     forward_inst = opt_meta
 
-        def has_readable_member(typ: Union[UnionType, Instance], name: str) -> bool:
+        def has_readable_member(typ: UnionType | Instance, name: str) -> bool:
             # TODO: Deal with attributes of TupleType etc.
             if isinstance(typ, Instance):
                 return typ.type.has_readable_member(name)
diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py
index 986e58c217620..aee8d58a69f69 100644
--- a/mypy/checkexpr.py
+++ b/mypy/checkexpr.py
@@ -6,8 +6,8 @@
 import time
 from collections import defaultdict
 from contextlib import contextmanager
-from typing import Callable, ClassVar, Iterable, Iterator, List, Optional, Sequence, cast
-from typing_extensions import Final, TypeAlias as _TypeAlias, overload
+from typing import Callable, ClassVar, Final, Iterable, Iterator, List, Optional, Sequence, cast
+from typing_extensions import TypeAlias as _TypeAlias, overload
 
 import mypy.checker
 import mypy.errorcodes as codes
@@ -5581,7 +5581,7 @@ def replace_callable_return_type(c: CallableType, new_ret_type: Type) -> Callabl
     return c.copy_modified(ret_type=new_ret_type)
 
 
-def apply_poly(tp: CallableType, poly_tvars: Sequence[TypeVarLikeType]) -> Optional[CallableType]:
+def apply_poly(tp: CallableType, poly_tvars: Sequence[TypeVarLikeType]) -> CallableType | None:
     """Make free type variables generic in the type if possible.
 
     This will translate the type `tp` while trying to create valid bindings for
diff --git a/mypy/checkpattern.py b/mypy/checkpattern.py
index 50d7b8a9826f0..e432675b0b5a9 100644
--- a/mypy/checkpattern.py
+++ b/mypy/checkpattern.py
@@ -3,8 +3,7 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import NamedTuple
-from typing_extensions import Final
+from typing import Final, NamedTuple
 
 import mypy.checker
 from mypy import message_registry
diff --git a/mypy/checkstrformat.py b/mypy/checkstrformat.py
index 974985d8b4fc7..cda603be086b1 100644
--- a/mypy/checkstrformat.py
+++ b/mypy/checkstrformat.py
@@ -13,8 +13,8 @@
 from __future__ import annotations
 
 import re
-from typing import TYPE_CHECKING, Callable, Dict, Match, Pattern, Tuple, Union, cast
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from typing import TYPE_CHECKING, Callable, Dict, Final, Match, Pattern, Tuple, Union, cast
+from typing_extensions import TypeAlias as _TypeAlias
 
 import mypy.errorcodes as codes
 from mypy.errors import Errors
diff --git a/mypy/config_parser.py b/mypy/config_parser.py
index 05af2ba6e21e7..47b0bc3acabc0 100644
--- a/mypy/config_parser.py
+++ b/mypy/config_parser.py
@@ -19,6 +19,7 @@
     Any,
     Callable,
     Dict,
+    Final,
     Iterable,
     List,
     Mapping,
@@ -28,7 +29,7 @@
     Tuple,
     Union,
 )
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from typing_extensions import TypeAlias as _TypeAlias
 
 from mypy import defaults
 from mypy.options import PER_MODULE_OPTIONS, Options
diff --git a/mypy/constant_fold.py b/mypy/constant_fold.py
index 6881ecae9e885..4582b2a7396d7 100644
--- a/mypy/constant_fold.py
+++ b/mypy/constant_fold.py
@@ -5,8 +5,7 @@
 
 from __future__ import annotations
 
-from typing import Union
-from typing_extensions import Final
+from typing import Final, Union
 
 from mypy.nodes import (
     ComplexExpr,
diff --git a/mypy/constraints.py b/mypy/constraints.py
index 803b9819be6f9..f9124630a706e 100644
--- a/mypy/constraints.py
+++ b/mypy/constraints.py
@@ -2,8 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Iterable, List, Sequence, cast
-from typing_extensions import Final
+from typing import TYPE_CHECKING, Final, Iterable, List, Sequence, cast
 
 import mypy.subtypes
 import mypy.typeops
diff --git a/mypy/defaults.py b/mypy/defaults.py
index 59a99cd58888c..2a881975a27ce 100644
--- a/mypy/defaults.py
+++ b/mypy/defaults.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import os
-from typing_extensions import Final
+from typing import Final
 
 PYTHON2_VERSION: Final = (2, 7)
 
diff --git a/mypy/dmypy_server.py b/mypy/dmypy_server.py
index 2427f83c57674..a50ebc5415ba9 100644
--- a/mypy/dmypy_server.py
+++ b/mypy/dmypy_server.py
@@ -17,8 +17,8 @@
 import time
 import traceback
 from contextlib import redirect_stderr, redirect_stdout
-from typing import AbstractSet, Any, Callable, List, Sequence, Tuple
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from typing import AbstractSet, Any, Callable, Final, List, Sequence, Tuple
+from typing_extensions import TypeAlias as _TypeAlias
 
 import mypy.build
 import mypy.errors
diff --git a/mypy/dmypy_util.py b/mypy/dmypy_util.py
index a1b419617f735..2aae41d998da4 100644
--- a/mypy/dmypy_util.py
+++ b/mypy/dmypy_util.py
@@ -6,8 +6,7 @@
 from __future__ import annotations
 
 import json
-from typing import Any
-from typing_extensions import Final
+from typing import Any, Final
 
 from mypy.ipc import IPCBase
 
diff --git a/mypy/errorcodes.py b/mypy/errorcodes.py
index b9448f3d5af92..68ae4b49a8061 100644
--- a/mypy/errorcodes.py
+++ b/mypy/errorcodes.py
@@ -6,7 +6,7 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from typing_extensions import Final
+from typing import Final
 
 from mypy_extensions import mypyc_attr
 
diff --git a/mypy/errors.py b/mypy/errors.py
index 6739d30f16a4b..2badac3e3d6d5 100644
--- a/mypy/errors.py
+++ b/mypy/errors.py
@@ -4,8 +4,8 @@
 import sys
 import traceback
 from collections import defaultdict
-from typing import Callable, Iterable, NoReturn, Optional, TextIO, Tuple, TypeVar
-from typing_extensions import Final, Literal, TypeAlias as _TypeAlias
+from typing import Callable, Final, Iterable, NoReturn, Optional, TextIO, Tuple, TypeVar
+from typing_extensions import Literal, TypeAlias as _TypeAlias
 
 from mypy import errorcodes as codes
 from mypy.errorcodes import IMPORT, ErrorCode
diff --git a/mypy/evalexpr.py b/mypy/evalexpr.py
index 2bc6966fa2fac..4b3abb1be3e2b 100644
--- a/mypy/evalexpr.py
+++ b/mypy/evalexpr.py
@@ -7,7 +7,7 @@
 
 """
 import ast
-from typing_extensions import Final
+from typing import Final
 
 import mypy.nodes
 from mypy.visitor import ExpressionVisitor
diff --git a/mypy/expandtype.py b/mypy/expandtype.py
index 24835a5ee4d6f..83d9bf4c8725d 100644
--- a/mypy/expandtype.py
+++ b/mypy/expandtype.py
@@ -1,7 +1,6 @@
 from __future__ import annotations
 
-from typing import Iterable, Mapping, Sequence, TypeVar, cast, overload
-from typing_extensions import Final
+from typing import Final, Iterable, Mapping, Sequence, TypeVar, cast, overload
 
 from mypy.nodes import ARG_POS, ARG_STAR, ArgKind, Var
 from mypy.state import state
diff --git a/mypy/fastparse.py b/mypy/fastparse.py
index fa185be21f9e3..eeeda16f9d8da 100644
--- a/mypy/fastparse.py
+++ b/mypy/fastparse.py
@@ -4,8 +4,8 @@
 import re
 import sys
 import warnings
-from typing import Any, Callable, List, Optional, Sequence, TypeVar, Union, cast
-from typing_extensions import Final, Literal, overload
+from typing import Any, Callable, Final, List, Optional, Sequence, TypeVar, Union, cast
+from typing_extensions import Literal, overload
 
 from mypy import defaults, errorcodes as codes, message_registry
 from mypy.errors import Errors
diff --git a/mypy/find_sources.py b/mypy/find_sources.py
index a3ef2d3db052f..3565fc4609cd9 100644
--- a/mypy/find_sources.py
+++ b/mypy/find_sources.py
@@ -4,8 +4,7 @@
 
 import functools
 import os
-from typing import Sequence
-from typing_extensions import Final
+from typing import Final, Sequence
 
 from mypy.fscache import FileSystemCache
 from mypy.modulefinder import PYTHON_EXTENSIONS, BuildSource, matches_exclude, mypy_path
@@ -160,7 +159,7 @@ def crawl_up(self, path: str) -> tuple[str, str]:
     def crawl_up_dir(self, dir: str) -> tuple[str, str]:
         return self._crawl_up_helper(dir) or ("", dir)
 
-    @functools.lru_cache()  # noqa: B019
+    @functools.lru_cache  # noqa: B019
     def _crawl_up_helper(self, dir: str) -> tuple[str, str] | None:
         """Given a directory, maybe returns module and base directory.
 
diff --git a/mypy/fixup.py b/mypy/fixup.py
index 15f4c13c20fa2..2b2e1210ee4e1 100644
--- a/mypy/fixup.py
+++ b/mypy/fixup.py
@@ -2,8 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Any
-from typing_extensions import Final
+from typing import Any, Final
 
 from mypy.lookup import lookup_fully_qualified
 from mypy.nodes import (
diff --git a/mypy/ipc.py b/mypy/ipc.py
index 21ef61918de57..d026f2429a0f2 100644
--- a/mypy/ipc.py
+++ b/mypy/ipc.py
@@ -12,8 +12,7 @@
 import sys
 import tempfile
 from types import TracebackType
-from typing import Callable
-from typing_extensions import Final
+from typing import Callable, Final
 
 if sys.platform == "win32":
     # This may be private, but it is needed for IPC on Windows, and is basically stable
diff --git a/mypy/literals.py b/mypy/literals.py
index 53ba559c56bba..cba5712644be2 100644
--- a/mypy/literals.py
+++ b/mypy/literals.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-from typing import Any, Iterable, Optional, Tuple
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from typing import Any, Final, Iterable, Optional, Tuple
+from typing_extensions import TypeAlias as _TypeAlias
 
 from mypy.nodes import (
     LITERAL_NO,
diff --git a/mypy/main.py b/mypy/main.py
index 9d95bb6cb1f62..f6e617e4d84f0 100644
--- a/mypy/main.py
+++ b/mypy/main.py
@@ -8,8 +8,7 @@
 import sys
 import time
 from gettext import gettext
-from typing import IO, Any, NoReturn, Sequence, TextIO
-from typing_extensions import Final
+from typing import IO, Any, Final, NoReturn, Sequence, TextIO
 
 from mypy import build, defaults, state, util
 from mypy.config_parser import get_config_module_names, parse_config_file, parse_version
diff --git a/mypy/message_registry.py b/mypy/message_registry.py
index 4e08f0dab5eda..bd3b8571b69e9 100644
--- a/mypy/message_registry.py
+++ b/mypy/message_registry.py
@@ -8,8 +8,7 @@
 
 from __future__ import annotations
 
-from typing import NamedTuple
-from typing_extensions import Final
+from typing import Final, NamedTuple
 
 from mypy import errorcodes as codes
 
diff --git a/mypy/messages.py b/mypy/messages.py
index 8e59e73291682..021ad2c7390cd 100644
--- a/mypy/messages.py
+++ b/mypy/messages.py
@@ -16,8 +16,7 @@
 import re
 from contextlib import contextmanager
 from textwrap import dedent
-from typing import Any, Callable, Collection, Iterable, Iterator, List, Sequence, cast
-from typing_extensions import Final
+from typing import Any, Callable, Collection, Final, Iterable, Iterator, List, Sequence, cast
 
 import mypy.typeops
 from mypy import errorcodes as codes, message_registry
diff --git a/mypy/modulefinder.py b/mypy/modulefinder.py
index e0406bffcc7be..c780015c639dc 100644
--- a/mypy/modulefinder.py
+++ b/mypy/modulefinder.py
@@ -21,8 +21,8 @@
 else:
     import tomli as tomllib
 
-from typing import Dict, List, NamedTuple, Optional, Tuple, Union
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from typing import Dict, Final, List, NamedTuple, Optional, Tuple, Union
+from typing_extensions import TypeAlias as _TypeAlias
 
 from mypy import pyinfo
 from mypy.fscache import FileSystemCache
diff --git a/mypy/nodes.py b/mypy/nodes.py
index 212ddb5def377..eb093f5d45b06 100644
--- a/mypy/nodes.py
+++ b/mypy/nodes.py
@@ -11,6 +11,7 @@
     Any,
     Callable,
     Dict,
+    Final,
     Iterator,
     List,
     Optional,
@@ -20,7 +21,7 @@
     Union,
     cast,
 )
-from typing_extensions import Final, TypeAlias as _TypeAlias, TypeGuard
+from typing_extensions import TypeAlias as _TypeAlias, TypeGuard
 
 from mypy_extensions import trait
 
diff --git a/mypy/operators.py b/mypy/operators.py
index 2b383ef199bb0..07ec5a24fa77c 100644
--- a/mypy/operators.py
+++ b/mypy/operators.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing_extensions import Final
+from typing import Final
 
 # Map from binary operator id to related method name (in Python 3).
 op_methods: Final = {
diff --git a/mypy/options.py b/mypy/options.py
index daa666dc76381..75343acd38bb1 100644
--- a/mypy/options.py
+++ b/mypy/options.py
@@ -4,8 +4,7 @@
 import re
 import sys
 import sysconfig
-from typing import Any, Callable, Dict, Mapping, Pattern
-from typing_extensions import Final
+from typing import Any, Callable, Final, Mapping, Pattern
 
 from mypy import defaults
 from mypy.errorcodes import ErrorCode, error_codes
@@ -529,7 +528,7 @@ def compile_glob(self, s: str) -> Pattern[str]:
         return re.compile(expr + "\\Z")
 
     def select_options_affecting_cache(self) -> Mapping[str, object]:
-        result: Dict[str, object] = {}
+        result: dict[str, object] = {}
         for opt in OPTIONS_AFFECTING_CACHE:
             val = getattr(self, opt)
             if opt in ("disabled_error_codes", "enabled_error_codes"):
diff --git a/mypy/plugins/attrs.py b/mypy/plugins/attrs.py
index e05a8e44b2f83..a6a383405ac6a 100644
--- a/mypy/plugins/attrs.py
+++ b/mypy/plugins/attrs.py
@@ -4,8 +4,8 @@
 
 from collections import defaultdict
 from functools import reduce
-from typing import Iterable, List, Mapping, cast
-from typing_extensions import Final, Literal
+from typing import Final, Iterable, List, Mapping, cast
+from typing_extensions import Literal
 
 import mypy.plugin  # To avoid circular imports.
 from mypy.applytype import apply_generic_arguments
diff --git a/mypy/plugins/dataclasses.py b/mypy/plugins/dataclasses.py
index efa1338962a05..7b3795b91a74e 100644
--- a/mypy/plugins/dataclasses.py
+++ b/mypy/plugins/dataclasses.py
@@ -2,8 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Iterator, Optional
-from typing_extensions import Final
+from typing import TYPE_CHECKING, Final, Iterator
 
 from mypy import errorcodes, message_registry
 from mypy.expandtype import expand_type, expand_type_by_instance
@@ -134,7 +133,7 @@ def to_argument(self, current_info: TypeInfo) -> Argument:
             kind=arg_kind,
         )
 
-    def expand_type(self, current_info: TypeInfo) -> Optional[Type]:
+    def expand_type(self, current_info: TypeInfo) -> Type | None:
         if self.type is not None and self.info.self_type is not None:
             # In general, it is not safe to call `expand_type()` during semantic analyzis,
             # however this plugin is called very late, so all types should be fully ready.
diff --git a/mypy/plugins/enums.py b/mypy/plugins/enums.py
index 1acf42d11ee6d..7869a8b5cdfab 100644
--- a/mypy/plugins/enums.py
+++ b/mypy/plugins/enums.py
@@ -12,8 +12,7 @@
 """
 from __future__ import annotations
 
-from typing import Iterable, Sequence, TypeVar, cast
-from typing_extensions import Final
+from typing import Final, Iterable, Sequence, TypeVar, cast
 
 import mypy.plugin  # To avoid circular imports.
 from mypy.nodes import TypeInfo
diff --git a/mypy/plugins/functools.py b/mypy/plugins/functools.py
index eba4d77f2343b..0aa2824c9b510 100644
--- a/mypy/plugins/functools.py
+++ b/mypy/plugins/functools.py
@@ -1,8 +1,7 @@
 """Plugin for supporting the functools standard library module."""
 from __future__ import annotations
 
-from typing import NamedTuple
-from typing_extensions import Final
+from typing import Final, NamedTuple
 
 import mypy.plugin
 from mypy.nodes import ARG_POS, ARG_STAR2, Argument, FuncItem, Var
diff --git a/mypy/plugins/singledispatch.py b/mypy/plugins/singledispatch.py
index a44493f900b14..c5ce20233a0a4 100644
--- a/mypy/plugins/singledispatch.py
+++ b/mypy/plugins/singledispatch.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-from typing import NamedTuple, Sequence, TypeVar, Union
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from typing import Final, NamedTuple, Sequence, TypeVar, Union
+from typing_extensions import TypeAlias as _TypeAlias
 
 from mypy.messages import format_type
 from mypy.nodes import ARG_POS, Argument, Block, ClassDef, Context, SymbolTable, TypeInfo, Var
diff --git a/mypy/reachability.py b/mypy/reachability.py
index 8602fc645e2b2..a25b9dff45813 100644
--- a/mypy/reachability.py
+++ b/mypy/reachability.py
@@ -2,8 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Tuple, TypeVar
-from typing_extensions import Final
+from typing import Final, Tuple, TypeVar
 
 from mypy.literals import literal
 from mypy.nodes import (
diff --git a/mypy/renaming.py b/mypy/renaming.py
index 2fa3ef168a66c..c960eb4b1ce82 100644
--- a/mypy/renaming.py
+++ b/mypy/renaming.py
@@ -1,8 +1,7 @@
 from __future__ import annotations
 
 from contextlib import contextmanager
-from typing import Iterator
-from typing_extensions import Final
+from typing import Final, Iterator
 
 from mypy.nodes import (
     AssignmentStmt,
diff --git a/mypy/report.py b/mypy/report.py
index 81d49baf50da5..5d93351aa37da 100644
--- a/mypy/report.py
+++ b/mypy/report.py
@@ -12,8 +12,8 @@
 import tokenize
 from abc import ABCMeta, abstractmethod
 from operator import attrgetter
-from typing import Any, Callable, Dict, Iterator, Tuple
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from typing import Any, Callable, Dict, Final, Iterator, Tuple
+from typing_extensions import TypeAlias as _TypeAlias
 from urllib.request import pathname2url
 
 from mypy import stats
diff --git a/mypy/semanal.py b/mypy/semanal.py
index 25393096bc5f0..75d41b3446989 100644
--- a/mypy/semanal.py
+++ b/mypy/semanal.py
@@ -51,8 +51,8 @@
 from __future__ import annotations
 
 from contextlib import contextmanager
-from typing import Any, Callable, Collection, Iterable, Iterator, List, TypeVar, cast
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from typing import Any, Callable, Collection, Final, Iterable, Iterator, List, TypeVar, cast
+from typing_extensions import TypeAlias as _TypeAlias
 
 from mypy import errorcodes as codes, message_registry
 from mypy.constant_fold import constant_fold_expr
diff --git a/mypy/semanal_classprop.py b/mypy/semanal_classprop.py
index 3f5bc9c4c2de2..dfd4e5b6f1224 100644
--- a/mypy/semanal_classprop.py
+++ b/mypy/semanal_classprop.py
@@ -5,7 +5,7 @@
 
 from __future__ import annotations
 
-from typing_extensions import Final
+from typing import Final
 
 from mypy.errors import Errors
 from mypy.nodes import (
diff --git a/mypy/semanal_enum.py b/mypy/semanal_enum.py
index f8d321ffada99..cd11204c3bcc6 100644
--- a/mypy/semanal_enum.py
+++ b/mypy/semanal_enum.py
@@ -5,8 +5,7 @@
 
 from __future__ import annotations
 
-from typing import cast
-from typing_extensions import Final
+from typing import Final, cast
 
 from mypy.nodes import (
     ARG_NAMED,
diff --git a/mypy/semanal_main.py b/mypy/semanal_main.py
index d7e9712fa4270..51a7014fac1ab 100644
--- a/mypy/semanal_main.py
+++ b/mypy/semanal_main.py
@@ -27,8 +27,8 @@
 from __future__ import annotations
 
 from contextlib import nullcontext
-from typing import TYPE_CHECKING, Callable, List, Optional, Tuple, Union
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from typing import TYPE_CHECKING, Callable, Final, List, Optional, Tuple, Union
+from typing_extensions import TypeAlias as _TypeAlias
 
 import mypy.build
 import mypy.state
diff --git a/mypy/semanal_namedtuple.py b/mypy/semanal_namedtuple.py
index 5eac02833d24c..42f7b10f3333d 100644
--- a/mypy/semanal_namedtuple.py
+++ b/mypy/semanal_namedtuple.py
@@ -6,8 +6,7 @@
 from __future__ import annotations
 
 from contextlib import contextmanager
-from typing import Iterator, List, Mapping, cast
-from typing_extensions import Final
+from typing import Final, Iterator, List, Mapping, cast
 
 from mypy.exprtotype import TypeTranslationError, expr_to_unanalyzed_type
 from mypy.nodes import (
diff --git a/mypy/semanal_shared.py b/mypy/semanal_shared.py
index d097e1fb08dc8..425e5906926a6 100644
--- a/mypy/semanal_shared.py
+++ b/mypy/semanal_shared.py
@@ -3,8 +3,8 @@
 from __future__ import annotations
 
 from abc import abstractmethod
-from typing import Callable, overload
-from typing_extensions import Final, Literal, Protocol
+from typing import Callable, Final, overload
+from typing_extensions import Literal, Protocol
 
 from mypy_extensions import trait
 
diff --git a/mypy/semanal_typeddict.py b/mypy/semanal_typeddict.py
index 47a3f558aa13e..aba5bf69b1303 100644
--- a/mypy/semanal_typeddict.py
+++ b/mypy/semanal_typeddict.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing_extensions import Final
+from typing import Final
 
 from mypy import errorcodes as codes, message_registry
 from mypy.errorcodes import ErrorCode
diff --git a/mypy/server/mergecheck.py b/mypy/server/mergecheck.py
index ef6f5b86c8f3c..6f044a5ea8b94 100644
--- a/mypy/server/mergecheck.py
+++ b/mypy/server/mergecheck.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing_extensions import Final
+from typing import Final
 
 from mypy.nodes import Decorator, FakeInfo, FuncDef, SymbolNode, Var
 from mypy.server.objgraph import get_path, get_reachable_graph
diff --git a/mypy/server/objgraph.py b/mypy/server/objgraph.py
index 37d0f4d2ca1a2..a13fd84129340 100644
--- a/mypy/server/objgraph.py
+++ b/mypy/server/objgraph.py
@@ -5,8 +5,7 @@
 import types
 import weakref
 from collections.abc import Iterable
-from typing import Iterator, Mapping
-from typing_extensions import Final
+from typing import Final, Iterator, Mapping
 
 method_descriptor_type: Final = type(object.__dir__)
 method_wrapper_type: Final = type(object().__ne__)
diff --git a/mypy/server/trigger.py b/mypy/server/trigger.py
index 5f2115739d382..97b5f89cd3ba5 100644
--- a/mypy/server/trigger.py
+++ b/mypy/server/trigger.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing_extensions import Final
+from typing import Final
 
 # Used as a suffix for triggers to handle "from m import *" dependencies (see also
 # make_wildcard_trigger)
diff --git a/mypy/server/update.py b/mypy/server/update.py
index dafed6642d1e6..0cc7a2229514d 100644
--- a/mypy/server/update.py
+++ b/mypy/server/update.py
@@ -118,8 +118,8 @@
 import re
 import sys
 import time
-from typing import Callable, NamedTuple, Sequence, Union
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from typing import Callable, Final, NamedTuple, Sequence, Union
+from typing_extensions import TypeAlias as _TypeAlias
 
 from mypy.build import (
     DEBUG_FINE_GRAINED,
diff --git a/mypy/sharedparse.py b/mypy/sharedparse.py
index 6f864ccce816d..ef2e4f7206649 100644
--- a/mypy/sharedparse.py
+++ b/mypy/sharedparse.py
@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing_extensions import Final
+from typing import Final
 
 """Shared logic between our three mypy parser files."""
 
diff --git a/mypy/state.py b/mypy/state.py
index 2e44a936f8190..cd3a360dd15f3 100644
--- a/mypy/state.py
+++ b/mypy/state.py
@@ -1,8 +1,7 @@
 from __future__ import annotations
 
 from contextlib import contextmanager
-from typing import Iterator
-from typing_extensions import Final
+from typing import Final, Iterator
 
 # These are global mutable state. Don't add anything here unless there's a very
 # good reason.
diff --git a/mypy/stats.py b/mypy/stats.py
index 5f4b9d4d201fc..b8803e03b9d2d 100644
--- a/mypy/stats.py
+++ b/mypy/stats.py
@@ -5,8 +5,7 @@
 import os
 from collections import Counter
 from contextlib import contextmanager
-from typing import Iterator
-from typing_extensions import Final
+from typing import Final, Iterator
 
 from mypy import nodes
 from mypy.argmap import map_formals_to_actuals
diff --git a/mypy/stubdoc.py b/mypy/stubdoc.py
index 7c8751bbd6ed1..232d9e9762e90 100644
--- a/mypy/stubdoc.py
+++ b/mypy/stubdoc.py
@@ -10,8 +10,8 @@
 import io
 import re
 import tokenize
-from typing import Any, MutableMapping, MutableSequence, NamedTuple, Sequence, Tuple
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from typing import Any, Final, MutableMapping, MutableSequence, NamedTuple, Sequence, Tuple
+from typing_extensions import TypeAlias as _TypeAlias
 
 # Type alias for signatures strings in format ('func_name', '(arg, opt_arg=False)').
 Sig: _TypeAlias = Tuple[str, str]
diff --git a/mypy/stubgen.py b/mypy/stubgen.py
index ba71456af4a42..229559ac81209 100755
--- a/mypy/stubgen.py
+++ b/mypy/stubgen.py
@@ -49,8 +49,7 @@
 import sys
 import traceback
 from collections import defaultdict
-from typing import Iterable, Mapping
-from typing_extensions import Final
+from typing import Final, Iterable, Mapping
 
 import mypy.build
 import mypy.mixedtraverser
diff --git a/mypy/stubgenc.py b/mypy/stubgenc.py
index 4fc9f8c6fdfaa..8aa1fb3d2c0a8 100755
--- a/mypy/stubgenc.py
+++ b/mypy/stubgenc.py
@@ -12,8 +12,7 @@
 import re
 from abc import abstractmethod
 from types import ModuleType
-from typing import Any, Iterable, Mapping
-from typing_extensions import Final
+from typing import Any, Final, Iterable, Mapping
 
 from mypy.moduleinspect import is_c_module
 from mypy.stubdoc import (
@@ -502,7 +501,7 @@ def generate_c_type_stub(
     """
     raw_lookup = getattr(obj, "__dict__")  # noqa: B009
     items = sorted(get_members(obj), key=lambda x: method_name_sort_key(x[0]))
-    names = set(x[0] for x in items)
+    names = {x[0] for x in items}
     methods: list[str] = []
     types: list[str] = []
     static_properties: list[str] = []
diff --git a/mypy/subtypes.py b/mypy/subtypes.py
index c9de56edfa36b..a6dc071f92b00 100644
--- a/mypy/subtypes.py
+++ b/mypy/subtypes.py
@@ -1,8 +1,8 @@
 from __future__ import annotations
 
 from contextlib import contextmanager
-from typing import Any, Callable, Iterator, List, TypeVar, cast
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from typing import Any, Callable, Final, Iterator, List, TypeVar, cast
+from typing_extensions import TypeAlias as _TypeAlias
 
 import mypy.applytype
 import mypy.constraints
diff --git a/mypy/test/data.py b/mypy/test/data.py
index 9b3931ee8be61..940776bf7b19a 100644
--- a/mypy/test/data.py
+++ b/mypy/test/data.py
@@ -12,8 +12,8 @@
 from abc import abstractmethod
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Iterator, NamedTuple, NoReturn, Pattern, Union
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from typing import Any, Final, Iterator, NamedTuple, NoReturn, Pattern, Union
+from typing_extensions import TypeAlias as _TypeAlias
 
 import pytest
 
diff --git a/mypy/type_visitor.py b/mypy/type_visitor.py
index 2efae49e9e103..cbfa43a77b812 100644
--- a/mypy/type_visitor.py
+++ b/mypy/type_visitor.py
@@ -14,8 +14,7 @@
 from __future__ import annotations
 
 from abc import abstractmethod
-from typing import Any, Callable, Generic, Iterable, Sequence, TypeVar, cast
-from typing_extensions import Final
+from typing import Any, Callable, Final, Generic, Iterable, Sequence, TypeVar, cast
 
 from mypy_extensions import mypyc_attr, trait
 
diff --git a/mypy/typeanal.py b/mypy/typeanal.py
index d577f355dbc8f..d894e2cc8c514 100644
--- a/mypy/typeanal.py
+++ b/mypy/typeanal.py
@@ -4,8 +4,8 @@
 
 import itertools
 from contextlib import contextmanager
-from typing import Callable, Iterable, Iterator, List, Sequence, Tuple, TypeVar
-from typing_extensions import Final, Protocol
+from typing import Callable, Final, Iterable, Iterator, List, Sequence, Tuple, TypeVar
+from typing_extensions import Protocol
 
 from mypy import errorcodes as codes, message_registry, nodes
 from mypy.errorcodes import ErrorCode
diff --git a/mypy/types.py b/mypy/types.py
index 131383790ec8c..784ef538f197f 100644
--- a/mypy/types.py
+++ b/mypy/types.py
@@ -9,6 +9,7 @@
     Any,
     ClassVar,
     Dict,
+    Final,
     Iterable,
     NamedTuple,
     NewType,
@@ -17,7 +18,7 @@
     Union,
     cast,
 )
-from typing_extensions import Final, Self, TypeAlias as _TypeAlias, TypeGuard, overload
+from typing_extensions import Self, TypeAlias as _TypeAlias, TypeGuard, overload
 
 import mypy.nodes
 from mypy.bogus_type import Bogus
diff --git a/mypy/typestate.py b/mypy/typestate.py
index ff5933af5928d..b32fb0ef6df14 100644
--- a/mypy/typestate.py
+++ b/mypy/typestate.py
@@ -5,8 +5,8 @@
 
 from __future__ import annotations
 
-from typing import Dict, Set, Tuple
-from typing_extensions import Final, TypeAlias as _TypeAlias
+from typing import Dict, Final, Set, Tuple
+from typing_extensions import TypeAlias as _TypeAlias
 
 from mypy.nodes import TypeInfo
 from mypy.server.trigger import make_trigger
diff --git a/mypy/util.py b/mypy/util.py
index 2960818d0984a..268ba8f9de813 100644
--- a/mypy/util.py
+++ b/mypy/util.py
@@ -11,8 +11,8 @@
 import sys
 import time
 from importlib import resources as importlib_resources
-from typing import IO, Callable, Container, Iterable, Sequence, Sized, TypeVar
-from typing_extensions import Final, Literal
+from typing import IO, Callable, Container, Final, Iterable, Sequence, Sized, TypeVar
+from typing_extensions import Literal
 
 try:
     import curses
diff --git a/mypyc/analysis/attrdefined.py b/mypyc/analysis/attrdefined.py
index 02e02a82a4f99..350158246cdb1 100644
--- a/mypyc/analysis/attrdefined.py
+++ b/mypyc/analysis/attrdefined.py
@@ -63,8 +63,7 @@ def foo(self) -> int:
 
 from __future__ import annotations
 
-from typing import Set, Tuple
-from typing_extensions import Final
+from typing import Final, Set, Tuple
 
 from mypyc.analysis.dataflow import (
     CFG,
@@ -414,7 +413,7 @@ def update_always_defined_attrs_using_subclasses(cl: ClassIR, seen: set[ClassIR]
     seen.add(cl)
 
 
-def detect_undefined_bitmap(cl: ClassIR, seen: Set[ClassIR]) -> None:
+def detect_undefined_bitmap(cl: ClassIR, seen: set[ClassIR]) -> None:
     if cl.is_trait:
         return
 
diff --git a/mypyc/codegen/cstring.py b/mypyc/codegen/cstring.py
index e006f12e09ecf..853787f8161d4 100644
--- a/mypyc/codegen/cstring.py
+++ b/mypyc/codegen/cstring.py
@@ -21,7 +21,7 @@
 from __future__ import annotations
 
 import string
-from typing_extensions import Final
+from typing import Final
 
 CHAR_MAP: Final = [f"\\{i:03o}" for i in range(256)]
 
diff --git a/mypyc/codegen/emit.py b/mypyc/codegen/emit.py
index 8f0e0bc65edc4..1bd376754ab94 100644
--- a/mypyc/codegen/emit.py
+++ b/mypyc/codegen/emit.py
@@ -5,8 +5,7 @@
 import pprint
 import sys
 import textwrap
-from typing import Callable
-from typing_extensions import Final
+from typing import Callable, Final
 
 from mypyc.codegen.literals import Literals
 from mypyc.common import (
@@ -926,7 +925,7 @@ def emit_unbox(
         elif is_float_rprimitive(typ):
             assert not optional  # Not supported for overlapping error values
             if declare_dest:
-                self.emit_line("double {};".format(dest))
+                self.emit_line(f"double {dest};")
             # TODO: Don't use __float__ and __index__
             self.emit_line(f"{dest} = PyFloat_AsDouble({src});")
             self.emit_lines(f"if ({dest} == -1.0 && PyErr_Occurred()) {{", failure, "}")
diff --git a/mypyc/codegen/emitfunc.py b/mypyc/codegen/emitfunc.py
index 7e6d775d74b4d..b4d31544b1967 100644
--- a/mypyc/codegen/emitfunc.py
+++ b/mypyc/codegen/emitfunc.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing_extensions import Final
+from typing import Final
 
 from mypyc.analysis.blockfreq import frequently_executed_blocks
 from mypyc.codegen.emit import DEBUG_ERRORS, Emitter, TracebackAndGotoHandler, c_array_initializer
@@ -686,10 +686,10 @@ def visit_float_op(self, op: FloatOp) -> None:
         lhs = self.reg(op.lhs)
         rhs = self.reg(op.rhs)
         if op.op != FloatOp.MOD:
-            self.emit_line("%s = %s %s %s;" % (dest, lhs, op.op_str[op.op], rhs))
+            self.emit_line(f"{dest} = {lhs} {op.op_str[op.op]} {rhs};")
         else:
             # TODO: This may set errno as a side effect, that is a little sketchy.
-            self.emit_line("%s = fmod(%s, %s);" % (dest, lhs, rhs))
+            self.emit_line(f"{dest} = fmod({lhs}, {rhs});")
 
     def visit_float_neg(self, op: FloatNeg) -> None:
         dest = self.reg(op)
@@ -700,7 +700,7 @@ def visit_float_comparison_op(self, op: FloatComparisonOp) -> None:
         dest = self.reg(op)
         lhs = self.reg(op.lhs)
         rhs = self.reg(op.rhs)
-        self.emit_line("%s = %s %s %s;" % (dest, lhs, op.op_str[op.op], rhs))
+        self.emit_line(f"{dest} = {lhs} {op.op_str[op.op]} {rhs};")
 
     def visit_load_mem(self, op: LoadMem) -> None:
         dest = self.reg(op)
diff --git a/mypyc/codegen/literals.py b/mypyc/codegen/literals.py
index 8f84089221c3e..1f0c3bc6ec7bd 100644
--- a/mypyc/codegen/literals.py
+++ b/mypyc/codegen/literals.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-from typing import FrozenSet, List, Tuple, Union
-from typing_extensions import Final, TypeGuard
+from typing import Final, FrozenSet, Tuple, Union
+from typing_extensions import TypeGuard
 
 # Supported Python literal types. All tuple / frozenset items must have supported
 # literal types as well, but we can't represent the type precisely.
@@ -140,7 +140,7 @@ def encoded_complex_values(self) -> list[str]:
     def encoded_tuple_values(self) -> list[str]:
         return self._encode_collection_values(self.tuple_literals)
 
-    def encoded_frozenset_values(self) -> List[str]:
+    def encoded_frozenset_values(self) -> list[str]:
         return self._encode_collection_values(self.frozenset_literals)
 
     def _encode_collection_values(
diff --git a/mypyc/common.py b/mypyc/common.py
index 05e13370cb98c..4615bf30d7427 100644
--- a/mypyc/common.py
+++ b/mypyc/common.py
@@ -2,8 +2,7 @@
 
 import sys
 import sysconfig
-from typing import Any, Dict
-from typing_extensions import Final
+from typing import Any, Dict, Final
 
 from mypy.util import unnamed_function
 
diff --git a/mypyc/ir/class_ir.py b/mypyc/ir/class_ir.py
index a5ac2133ce134..682e306291189 100644
--- a/mypyc/ir/class_ir.py
+++ b/mypyc/ir/class_ir.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import List, NamedTuple, Optional
+from typing import List, NamedTuple
 
 from mypyc.common import PROPSET_PREFIX, JsonDict
 from mypyc.ir.func_ir import FuncDecl, FuncIR, FuncSignature
@@ -73,7 +73,7 @@ class VTableMethod(NamedTuple):
     cls: "ClassIR"
     name: str
     method: FuncIR
-    shadow_method: Optional[FuncIR]
+    shadow_method: FuncIR | None
 
 
 VTableEntries = List[VTableMethod]
@@ -192,7 +192,7 @@ def __init__(
         # bitmap for types such as native ints that can't have a dedicated error
         # value that doesn't overlap a valid value. The bitmap is used if the
         # value of an attribute is the same as the error value.
-        self.bitmap_attrs: List[str] = []
+        self.bitmap_attrs: list[str] = []
 
     def __repr__(self) -> str:
         return (
diff --git a/mypyc/ir/func_ir.py b/mypyc/ir/func_ir.py
index dbb45fc7ec294..44847c7bb0b3b 100644
--- a/mypyc/ir/func_ir.py
+++ b/mypyc/ir/func_ir.py
@@ -2,8 +2,7 @@
 
 from __future__ import annotations
 
-from typing import Sequence
-from typing_extensions import Final
+from typing import Final, Sequence
 
 from mypy.nodes import ARG_POS, ArgKind, Block, FuncDef
 from mypyc.common import BITMAP_BITS, JsonDict, bitmap_name, get_id_from_name, short_id_from_name
@@ -86,7 +85,7 @@ def real_args(self) -> tuple[RuntimeArg, ...]:
             return self.args[: -self.num_bitmap_args]
         return self.args
 
-    def bound_sig(self) -> "FuncSignature":
+    def bound_sig(self) -> FuncSignature:
         if self.num_bitmap_args:
             return FuncSignature(self.args[1 : -self.num_bitmap_args], self.ret_type)
         else:
diff --git a/mypyc/ir/ops.py b/mypyc/ir/ops.py
index 6007f8a4ce042..cb8d9662820c5 100644
--- a/mypyc/ir/ops.py
+++ b/mypyc/ir/ops.py
@@ -12,8 +12,7 @@
 from __future__ import annotations
 
 from abc import abstractmethod
-from typing import TYPE_CHECKING, Dict, Generic, List, NamedTuple, Sequence, TypeVar, Union
-from typing_extensions import Final
+from typing import TYPE_CHECKING, Final, Generic, List, NamedTuple, Sequence, TypeVar, Union
 
 from mypy_extensions import trait
 
@@ -1204,10 +1203,10 @@ def __init__(self, lhs: Value, rhs: Value, op: int, line: int = -1) -> None:
         self.rhs = rhs
         self.op = op
 
-    def sources(self) -> List[Value]:
+    def sources(self) -> list[Value]:
         return [self.lhs, self.rhs]
 
-    def accept(self, visitor: "OpVisitor[T]") -> T:
+    def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_float_op(self)
 
 
@@ -1226,10 +1225,10 @@ def __init__(self, src: Value, line: int = -1) -> None:
         self.type = float_rprimitive
         self.src = src
 
-    def sources(self) -> List[Value]:
+    def sources(self) -> list[Value]:
         return [self.src]
 
-    def accept(self, visitor: "OpVisitor[T]") -> T:
+    def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_float_neg(self)
 
 
@@ -1254,10 +1253,10 @@ def __init__(self, lhs: Value, rhs: Value, op: int, line: int = -1) -> None:
         self.rhs = rhs
         self.op = op
 
-    def sources(self) -> List[Value]:
+    def sources(self) -> list[Value]:
         return [self.lhs, self.rhs]
 
-    def accept(self, visitor: "OpVisitor[T]") -> T:
+    def accept(self, visitor: OpVisitor[T]) -> T:
         return visitor.visit_float_comparison_op(self)
 
 
@@ -1575,5 +1574,5 @@ def visit_keep_alive(self, op: KeepAlive) -> T:
 # (Serialization and deserialization *will* be used for incremental
 # compilation but so far it is not hooked up to anything.)
 class DeserMaps(NamedTuple):
-    classes: Dict[str, "ClassIR"]
-    functions: Dict[str, "FuncIR"]
+    classes: dict[str, "ClassIR"]
+    functions: dict[str, "FuncIR"]
diff --git a/mypyc/ir/pprint.py b/mypyc/ir/pprint.py
index 4d10a91835cac..c86060c495945 100644
--- a/mypyc/ir/pprint.py
+++ b/mypyc/ir/pprint.py
@@ -3,8 +3,7 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import Any, Sequence, Union
-from typing_extensions import Final
+from typing import Any, Final, Sequence, Union
 
 from mypyc.common import short_name
 from mypyc.ir.func_ir import FuncIR, all_values_full
diff --git a/mypyc/ir/rtypes.py b/mypyc/ir/rtypes.py
index 61f83c9c041eb..fe0c51ea2221d 100644
--- a/mypyc/ir/rtypes.py
+++ b/mypyc/ir/rtypes.py
@@ -23,8 +23,7 @@
 from __future__ import annotations
 
 from abc import abstractmethod
-from typing import TYPE_CHECKING, ClassVar, Generic, TypeVar
-from typing_extensions import Final
+from typing import TYPE_CHECKING, ClassVar, Final, Generic, TypeVar
 
 from mypyc.common import IS_32_BIT_PLATFORM, PLATFORM_SIZE, JsonDict, short_name
 from mypyc.namegen import NameGenerator
diff --git a/mypyc/irbuild/builder.py b/mypyc/irbuild/builder.py
index 86c28882d7388..10f057a29bbb9 100644
--- a/mypyc/irbuild/builder.py
+++ b/mypyc/irbuild/builder.py
@@ -13,8 +13,8 @@
 from __future__ import annotations
 
 from contextlib import contextmanager
-from typing import Any, Callable, Iterator, Sequence, Union
-from typing_extensions import Final, overload
+from typing import Any, Callable, Final, Iterator, Sequence, Union
+from typing_extensions import overload
 
 from mypy.build import Graph
 from mypy.maptype import map_instance_to_supertype
diff --git a/mypyc/irbuild/classdef.py b/mypyc/irbuild/classdef.py
index ef8db97c818e2..fc2bb4a1fc2f3 100644
--- a/mypyc/irbuild/classdef.py
+++ b/mypyc/irbuild/classdef.py
@@ -4,8 +4,7 @@
 
 import typing_extensions
 from abc import abstractmethod
-from typing import Callable
-from typing_extensions import Final
+from typing import Callable, Final
 
 from mypy.nodes import (
     AssignmentStmt,
diff --git a/mypyc/irbuild/constant_fold.py b/mypyc/irbuild/constant_fold.py
index dc21be4689e28..12a4b15dd40c8 100644
--- a/mypyc/irbuild/constant_fold.py
+++ b/mypyc/irbuild/constant_fold.py
@@ -10,8 +10,7 @@
 
 from __future__ import annotations
 
-from typing import Union
-from typing_extensions import Final
+from typing import Final, Union
 
 from mypy.constant_fold import constant_fold_binary_op, constant_fold_unary_op
 from mypy.nodes import (
diff --git a/mypyc/irbuild/format_str_tokenizer.py b/mypyc/irbuild/format_str_tokenizer.py
index 480c683aa1641..0b46887811fb5 100644
--- a/mypyc/irbuild/format_str_tokenizer.py
+++ b/mypyc/irbuild/format_str_tokenizer.py
@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from enum import Enum, unique
-from typing_extensions import Final
+from typing import Final
 
 from mypy.checkstrformat import (
     ConversionSpecifier,
diff --git a/mypyc/irbuild/ll_builder.py b/mypyc/irbuild/ll_builder.py
index a37bcc0dbb86a..e34f037040476 100644
--- a/mypyc/irbuild/ll_builder.py
+++ b/mypyc/irbuild/ll_builder.py
@@ -10,8 +10,7 @@
 
 from __future__ import annotations
 
-from typing import Callable, Optional, Sequence, Tuple
-from typing_extensions import Final
+from typing import Callable, Final, Optional, Sequence, Tuple
 
 from mypy.argmap import map_actuals_to_formals
 from mypy.nodes import ARG_POS, ARG_STAR, ARG_STAR2, ArgKind
diff --git a/mypyc/irbuild/specialize.py b/mypyc/irbuild/specialize.py
index 06af4d6d74269..2f22b4bfc9d20 100644
--- a/mypyc/irbuild/specialize.py
+++ b/mypyc/irbuild/specialize.py
@@ -755,7 +755,7 @@ def translate_bool(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value
 
 
 @specialize_function("builtins.float")
-def translate_float(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Optional[Value]:
+def translate_float(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
     if len(expr.args) != 1 or expr.arg_kinds[0] != ARG_POS:
         return None
     arg = expr.args[0]
diff --git a/mypyc/primitives/registry.py b/mypyc/primitives/registry.py
index 1e2cf2695ee7c..aa96b35aec562 100644
--- a/mypyc/primitives/registry.py
+++ b/mypyc/primitives/registry.py
@@ -37,8 +37,7 @@
 
 from __future__ import annotations
 
-from typing import List, NamedTuple, Optional, Tuple
-from typing_extensions import Final
+from typing import Final, NamedTuple
 
 from mypyc.ir.ops import StealsDescription
 from mypyc.ir.rtypes import RType
@@ -50,16 +49,16 @@
 
 class CFunctionDescription(NamedTuple):
     name: str
-    arg_types: List[RType]
+    arg_types: list[RType]
     return_type: RType
-    var_arg_type: Optional[RType]
-    truncated_type: Optional[RType]
+    var_arg_type: RType | None
+    truncated_type: RType | None
     c_function_name: str
     error_kind: int
     steals: StealsDescription
     is_borrowed: bool
-    ordering: Optional[List[int]]
-    extra_int_constants: List[Tuple[int, RType]]
+    ordering: list[int] | None
+    extra_int_constants: list[tuple[int, RType]]
     priority: int
 
 
diff --git a/mypyc/test-data/fixtures/testutil.py b/mypyc/test-data/fixtures/testutil.py
index 5a4b1d0f549e2..7f00ee5aea001 100644
--- a/mypyc/test-data/fixtures/testutil.py
+++ b/mypyc/test-data/fixtures/testutil.py
@@ -7,7 +7,7 @@
     Any, Iterator, TypeVar, Generator, Optional, List, Tuple, Sequence,
     Union, Callable, Awaitable,
 )
-from typing_extensions import Final
+from typing import Final
 
 FLOAT_MAGIC: Final = -113.0
 

From e86f097ee9dac7488ccd0d444182e33733710c42 Mon Sep 17 00:00:00 2001
From: Nikita Sobolev <mail@sobolevn.me>
Date: Mon, 3 Jul 2023 23:26:27 +0300
Subject: [PATCH 102/129] Target py3.8+ for black (#15583)

---
 pyproject.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index 0f2712be52dd5..1fc52df4bcb80 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -17,7 +17,7 @@ build-backend = "setuptools.build_meta"
 
 [tool.black]
 line-length = 99
-target-version = ["py37", "py38", "py39", "py310", "py311"]
+target-version = ["py38", "py39", "py310", "py311"]
 skip-magic-trailing-comma = true
 force-exclude = '''
 ^/mypy/typeshed|

From 781dc8f82adacce730293479517fd0fb5944c255 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Mon, 3 Jul 2023 22:59:27 +0100
Subject: [PATCH 103/129] [mypyc] Fix self-compilation on Python 3.12 (#15582)

---
 mypyc/build.py | 38 ++++++++++++++++++++++++--------------
 1 file changed, 24 insertions(+), 14 deletions(-)

diff --git a/mypyc/build.py b/mypyc/build.py
index 5fc041e2dcf24..9889577d4addd 100644
--- a/mypyc/build.py
+++ b/mypyc/build.py
@@ -40,23 +40,31 @@
 from mypyc.namegen import exported_name
 from mypyc.options import CompilerOptions
 
-if TYPE_CHECKING:
-    from distutils.core import Extension as _distutils_Extension
-    from typing_extensions import TypeAlias
+if sys.version_info < (3, 12):
+    if TYPE_CHECKING:
+        from distutils.core import Extension as _distutils_Extension
+        from typing_extensions import TypeAlias
 
-    from setuptools import Extension as _setuptools_Extension
+        from setuptools import Extension as _setuptools_Extension
 
-    Extension: TypeAlias = Union[_setuptools_Extension, _distutils_Extension]
+        Extension: TypeAlias = Union[_setuptools_Extension, _distutils_Extension]
 
-
-try:
-    # Import setuptools so that it monkey-patch overrides distutils
+    try:
+        # Import setuptools so that it monkey-patch overrides distutils
+        import setuptools
+    except ImportError:
+        pass
+    from distutils import ccompiler, sysconfig
+else:
     import setuptools
-except ImportError:
-    if sys.version_info >= (3, 12):
-        # Raise on Python 3.12, since distutils will go away forever
-        raise
-from distutils import ccompiler, sysconfig
+    from setuptools import Extension
+    from setuptools._distutils import (
+        ccompiler as _ccompiler,  # type: ignore[attr-defined]
+        sysconfig as _sysconfig,  # type: ignore[attr-defined]
+    )
+
+    ccompiler = _ccompiler
+    sysconfig = _sysconfig
 
 
 def get_extension() -> type[Extension]:
@@ -65,11 +73,13 @@ def get_extension() -> type[Extension]:
     use_setuptools = "setuptools" in sys.modules
     extension_class: type[Extension]
 
-    if not use_setuptools:
+    if sys.version_info < (3, 12) and not use_setuptools:
         import distutils.core
 
         extension_class = distutils.core.Extension
     else:
+        if not use_setuptools:
+            sys.exit("error: setuptools not installed")
         extension_class = setuptools.Extension
 
     return extension_class

From cb0a44630a0608994116e3de3be07b6d3b14381a Mon Sep 17 00:00:00 2001
From: Federico Padua <fermilab_fede@hotmail.it>
Date: Tue, 4 Jul 2023 16:28:49 +0200
Subject: [PATCH 104/129] Fix variable name in comment in `getting_started.rst`
 (#15587)

This PR fixes a word within a code block of the `Getting Started/Types
from libraries` documentation.
In particular, the variable name `file_path` is used instead of the
correct `template_path`.
This commit fixes that and it replaces `file_path` with `template_path`.

This PR doesn't change the behaviour of `mypy` code since it involves
just a word change in the documentation, so no tests are provided and it
is expected that current working code works as usual, given the change
made by this PR.
---
 docs/source/getting_started.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/source/getting_started.rst b/docs/source/getting_started.rst
index 11f915005695a..463c73b2fe761 100644
--- a/docs/source/getting_started.rst
+++ b/docs/source/getting_started.rst
@@ -264,7 +264,7 @@ Python standard library. For example, here is a function which uses the
     from pathlib import Path
 
     def load_template(template_path: Path, name: str) -> str:
-        # Mypy knows that `file_path` has a `read_text` method that returns a str
+        # Mypy knows that `template_path` has a `read_text` method that returns a str
         template = template_path.read_text()
         # ...so it understands this line type checks
         return template.replace('USERNAME', name)

From 913477ee68094b137d3a70f4724a460db1400a7e Mon Sep 17 00:00:00 2001
From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
Date: Tue, 4 Jul 2023 17:00:04 +0200
Subject: [PATCH 105/129] Target py38 for ruff (#15585)

---
 pyproject.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index 1fc52df4bcb80..67201acb9b94f 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -27,7 +27,7 @@ force-exclude = '''
 
 [tool.ruff]
 line-length = 99
-target-version = "py37"
+target-version = "py38"
 fix = true
 
 select = [

From 85ba5745afcc646c1728dbb690bfb196537abe04 Mon Sep 17 00:00:00 2001
From: Erik Kemperman <erikkemperman@gmail.com>
Date: Tue, 4 Jul 2023 20:17:31 +0200
Subject: [PATCH 106/129] Handle type same as typing.Type in classmethod 1st
 arg (#15297)

---
 mypy/semanal.py                    | 16 ++++++++++++-
 test-data/unit/check-selftype.test | 36 ++++++++++++++++++++++++++++++
 2 files changed, 51 insertions(+), 1 deletion(-)

diff --git a/mypy/semanal.py b/mypy/semanal.py
index 75d41b3446989..1f15691ae205b 100644
--- a/mypy/semanal.py
+++ b/mypy/semanal.py
@@ -1008,7 +1008,21 @@ def is_expected_self_type(self, typ: Type, is_classmethod: bool) -> bool:
                 return self.is_expected_self_type(typ.item, is_classmethod=False)
             if isinstance(typ, UnboundType):
                 sym = self.lookup_qualified(typ.name, typ, suppress_errors=True)
-                if sym is not None and sym.fullname == "typing.Type" and typ.args:
+                if (
+                    sym is not None
+                    and (
+                        sym.fullname == "typing.Type"
+                        or (
+                            sym.fullname == "builtins.type"
+                            and (
+                                self.is_stub_file
+                                or self.is_future_flag_set("annotations")
+                                or self.options.python_version >= (3, 9)
+                            )
+                        )
+                    )
+                    and typ.args
+                ):
                     return self.is_expected_self_type(typ.args[0], is_classmethod=False)
             return False
         if isinstance(typ, TypeVarType):
diff --git a/test-data/unit/check-selftype.test b/test-data/unit/check-selftype.test
index 96d5b2306427f..4155e33438516 100644
--- a/test-data/unit/check-selftype.test
+++ b/test-data/unit/check-selftype.test
@@ -1665,6 +1665,23 @@ class C:
         return cls()
 [builtins fixtures/classmethod.pyi]
 
+[case testTypingSelfRedundantAllowed_pep585]
+# flags: --python-version 3.9
+from typing import Self
+
+class C:
+    def f(self: Self) -> Self:
+        d: Defer
+        class Defer: ...
+        return self
+
+    @classmethod
+    def g(cls: type[Self]) -> Self:
+        d: DeferAgain
+        class DeferAgain: ...
+        return cls()
+[builtins fixtures/classmethod.pyi]
+
 [case testTypingSelfRedundantWarning]
 # mypy: enable-error-code="redundant-self"
 
@@ -1683,6 +1700,25 @@ class C:
         return cls()
 [builtins fixtures/classmethod.pyi]
 
+[case testTypingSelfRedundantWarning_pep585]
+# flags: --python-version 3.9
+# mypy: enable-error-code="redundant-self"
+
+from typing import Self
+
+class C:
+    def copy(self: Self) -> Self:  # E: Redundant "Self" annotation for the first method argument
+        d: Defer
+        class Defer: ...
+        return self
+
+    @classmethod
+    def g(cls: type[Self]) -> Self:  # E: Redundant "Self" annotation for the first method argument
+        d: DeferAgain
+        class DeferAgain: ...
+        return cls()
+[builtins fixtures/classmethod.pyi]
+
 [case testTypingSelfAssertType]
 from typing import Self, assert_type
 

From 59ba4293679dbed20a6d67fc3eff88d8f98eda43 Mon Sep 17 00:00:00 2001
From: Valentin Stanciu <250871+svalentin@users.noreply.github.com>
Date: Tue, 4 Jul 2023 19:40:46 +0100
Subject: [PATCH 107/129] When sync-typeshed fails to apply CP allow manual
 user merges (#15591)

If misc/sync-typeshed.py fails to apply a cherry pick, it just fails.
Let's try to give the user a chance to manually merge the CP and
continue with the script.
This should block for user input only in cases where stdin is a tty. So
automation should continue failing. (but the only way to test is by
running it)

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: Alex Waygood <Alex.Waygood@Gmail.com>
---
 misc/sync-typeshed.py | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/misc/sync-typeshed.py b/misc/sync-typeshed.py
index a8aca425696a9..cbaa7029620f4 100644
--- a/misc/sync-typeshed.py
+++ b/misc/sync-typeshed.py
@@ -185,7 +185,21 @@ def main() -> None:
         "9f3bbbeb1",  # ParamSpec for functools.wraps
     ]
     for commit in commits_to_cherry_pick:
-        subprocess.run(["git", "cherry-pick", commit], check=True)
+        try:
+            subprocess.run(["git", "cherry-pick", commit], check=True)
+        except subprocess.CalledProcessError:
+            if not sys.__stdin__.isatty():
+                # We're in an automated context
+                raise
+
+            # Allow the option to merge manually
+            print(
+                f"Commit {commit} failed to cherry pick."
+                " In a separate shell, please manually merge and continue cherry pick."
+            )
+            rsp = input("Did you finish the cherry pick? [y/N]: ")
+            if rsp.lower() not in {"y", "yes"}:
+                raise
         print(f"Cherry-picked {commit}.")
 
     if args.make_pr:

From c44fe1a6bf09413d0dd74a354e479e8b041c4a04 Mon Sep 17 00:00:00 2001
From: AlexWaygood <alex.waygood@gmail.com>
Date: Tue, 4 Jul 2023 18:18:52 +0100
Subject: [PATCH 108/129] Sync typeshed

Source commit:
https://github.com/python/typeshed/commit/fc7d4722eaa54803926cee5730e1f784979c0531
---
 mypy/typeshed/stdlib/_collections_abc.pyi     |   2 +-
 mypy/typeshed/stdlib/_ctypes.pyi              |   6 +-
 mypy/typeshed/stdlib/asyncio/__init__.pyi     |   4 +-
 mypy/typeshed/stdlib/asyncio/base_events.pyi  |   4 +-
 mypy/typeshed/stdlib/asyncio/events.pyi       |   4 +-
 mypy/typeshed/stdlib/builtins.pyi             | 103 +++++++++++++++++-
 mypy/typeshed/stdlib/codecs.pyi               |   1 +
 mypy/typeshed/stdlib/collections/__init__.pyi |  10 +-
 mypy/typeshed/stdlib/email/utils.pyi          |   9 +-
 mypy/typeshed/stdlib/enum.pyi                 |  11 +-
 mypy/typeshed/stdlib/functools.pyi            |  40 ++++---
 mypy/typeshed/stdlib/http/client.pyi          |  39 ++++---
 mypy/typeshed/stdlib/inspect.pyi              |  30 ++++-
 mypy/typeshed/stdlib/pydoc.pyi                |  30 +++--
 mypy/typeshed/stdlib/socket.pyi               |   2 +
 mypy/typeshed/stdlib/tempfile.pyi             |   1 +
 mypy/typeshed/stdlib/types.pyi                |  45 ++++----
 mypy/typeshed/stdlib/typing.pyi               |  41 ++++---
 mypy/typeshed/stdlib/unittest/mock.pyi        |   5 +-
 19 files changed, 290 insertions(+), 97 deletions(-)

diff --git a/mypy/typeshed/stdlib/_collections_abc.pyi b/mypy/typeshed/stdlib/_collections_abc.pyi
index 05b5421c21f33..ba2f638d81c93 100644
--- a/mypy/typeshed/stdlib/_collections_abc.pyi
+++ b/mypy/typeshed/stdlib/_collections_abc.pyi
@@ -1,7 +1,7 @@
 import sys
 from abc import abstractmethod
 from types import MappingProxyType
-from typing import (  # noqa: Y022,Y038
+from typing import (  # noqa: Y022,Y038,Y057
     AbstractSet as Set,
     AsyncGenerator as AsyncGenerator,
     AsyncIterable as AsyncIterable,
diff --git a/mypy/typeshed/stdlib/_ctypes.pyi b/mypy/typeshed/stdlib/_ctypes.pyi
index 756ee86d33429..25d604218a00d 100644
--- a/mypy/typeshed/stdlib/_ctypes.pyi
+++ b/mypy/typeshed/stdlib/_ctypes.pyi
@@ -151,7 +151,11 @@ class Array(Generic[_CT], _CData):
     def _type_(self) -> type[_CT]: ...
     @_type_.setter
     def _type_(self, value: type[_CT]) -> None: ...
-    raw: bytes  # Note: only available if _CT == c_char
+    # Note: only available if _CT == c_char
+    @property
+    def raw(self) -> bytes: ...
+    @raw.setter
+    def raw(self, value: ReadableBuffer) -> None: ...
     value: Any  # Note: bytes if _CT == c_char, str if _CT == c_wchar, unavailable otherwise
     # TODO These methods cannot be annotated correctly at the moment.
     # All of these "Any"s stand for the array's element type, but it's not possible to use _CT
diff --git a/mypy/typeshed/stdlib/asyncio/__init__.pyi b/mypy/typeshed/stdlib/asyncio/__init__.pyi
index 2ce066cac9821..c114651843899 100644
--- a/mypy/typeshed/stdlib/asyncio/__init__.pyi
+++ b/mypy/typeshed/stdlib/asyncio/__init__.pyi
@@ -36,8 +36,8 @@ _T = TypeVar("_T")
 
 # Aliases imported by multiple submodules in typeshed
 if sys.version_info >= (3, 12):
-    _AwaitableLike: TypeAlias = Awaitable[_T]
-    _CoroutineLike: TypeAlias = Coroutine[Any, Any, _T]
+    _AwaitableLike: TypeAlias = Awaitable[_T]  # noqa: Y047
+    _CoroutineLike: TypeAlias = Coroutine[Any, Any, _T]  # noqa: Y047
 else:
     _AwaitableLike: TypeAlias = Generator[Any, None, _T] | Awaitable[_T]
     _CoroutineLike: TypeAlias = Generator[Any, None, _T] | Coroutine[Any, Any, _T]
diff --git a/mypy/typeshed/stdlib/asyncio/base_events.pyi b/mypy/typeshed/stdlib/asyncio/base_events.pyi
index fd765fdb06143..9924f728f6eae 100644
--- a/mypy/typeshed/stdlib/asyncio/base_events.pyi
+++ b/mypy/typeshed/stdlib/asyncio/base_events.pyi
@@ -263,7 +263,7 @@ class BaseEventLoop(AbstractEventLoop):
             server_hostname: str | None = None,
             ssl_handshake_timeout: float | None = None,
             ssl_shutdown_timeout: float | None = None,
-        ) -> Transport: ...
+        ) -> Transport | None: ...
         async def connect_accepted_socket(
             self,
             protocol_factory: Callable[[], _ProtocolT],
@@ -317,7 +317,7 @@ class BaseEventLoop(AbstractEventLoop):
             server_side: bool = False,
             server_hostname: str | None = None,
             ssl_handshake_timeout: float | None = None,
-        ) -> Transport: ...
+        ) -> Transport | None: ...
         async def connect_accepted_socket(
             self,
             protocol_factory: Callable[[], _ProtocolT],
diff --git a/mypy/typeshed/stdlib/asyncio/events.pyi b/mypy/typeshed/stdlib/asyncio/events.pyi
index 11112bb2e87d5..2054f6e522a14 100644
--- a/mypy/typeshed/stdlib/asyncio/events.pyi
+++ b/mypy/typeshed/stdlib/asyncio/events.pyi
@@ -358,7 +358,7 @@ class AbstractEventLoop:
             server_hostname: str | None = None,
             ssl_handshake_timeout: float | None = None,
             ssl_shutdown_timeout: float | None = None,
-        ) -> Transport: ...
+        ) -> Transport | None: ...
         async def create_unix_server(
             self,
             protocol_factory: _ProtocolFactory,
@@ -418,7 +418,7 @@ class AbstractEventLoop:
             server_side: bool = False,
             server_hostname: str | None = None,
             ssl_handshake_timeout: float | None = None,
-        ) -> Transport: ...
+        ) -> Transport | None: ...
         async def create_unix_server(
             self,
             protocol_factory: _ProtocolFactory,
diff --git a/mypy/typeshed/stdlib/builtins.pyi b/mypy/typeshed/stdlib/builtins.pyi
index 4337a44c7c684..45a17b33d979e 100644
--- a/mypy/typeshed/stdlib/builtins.pyi
+++ b/mypy/typeshed/stdlib/builtins.pyi
@@ -53,9 +53,10 @@ from typing import (  # noqa: Y022
     overload,
     type_check_only,
 )
-from typing_extensions import (  # type: ignore
+from typing_extensions import (
     Concatenate,
     Literal,
+    LiteralString,
     ParamSpec,
     Self,
     SupportsIndex,
@@ -432,8 +433,17 @@ class str(Sequence[str]):
     def __new__(cls, object: object = ...) -> Self: ...
     @overload
     def __new__(cls, object: ReadableBuffer, encoding: str = ..., errors: str = ...) -> Self: ...
+    @overload
+    def capitalize(self: LiteralString) -> LiteralString: ...
+    @overload
     def capitalize(self) -> str: ...  # type: ignore[misc]
+    @overload
+    def casefold(self: LiteralString) -> LiteralString: ...
+    @overload
     def casefold(self) -> str: ...  # type: ignore[misc]
+    @overload
+    def center(self: LiteralString, __width: SupportsIndex, __fillchar: LiteralString = " ") -> LiteralString: ...
+    @overload
     def center(self, __width: SupportsIndex, __fillchar: str = " ") -> str: ...  # type: ignore[misc]
     def count(self, x: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
     def encode(self, encoding: str = "utf-8", errors: str = "strict") -> bytes: ...
@@ -441,12 +451,21 @@ class str(Sequence[str]):
         self, __suffix: str | tuple[str, ...], __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...
     ) -> bool: ...
     if sys.version_info >= (3, 8):
+        @overload
+        def expandtabs(self: LiteralString, tabsize: SupportsIndex = 8) -> LiteralString: ...
+        @overload
         def expandtabs(self, tabsize: SupportsIndex = 8) -> str: ...  # type: ignore[misc]
     else:
+        @overload
+        def expandtabs(self: LiteralString, tabsize: int = 8) -> LiteralString: ...
+        @overload
         def expandtabs(self, tabsize: int = 8) -> str: ...  # type: ignore[misc]
 
     def find(self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
-    def format(self, *args: object, **kwargs: object) -> str: ...  # type: ignore
+    @overload
+    def format(self: LiteralString, *args: LiteralString, **kwargs: LiteralString) -> LiteralString: ...
+    @overload
+    def format(self, *args: object, **kwargs: object) -> str: ...
     def format_map(self, map: _FormatMapMapping) -> str: ...
     def index(self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
     def isalnum(self) -> bool: ...
@@ -461,32 +480,91 @@ class str(Sequence[str]):
     def isspace(self) -> bool: ...
     def istitle(self) -> bool: ...
     def isupper(self) -> bool: ...
+    @overload
+    def join(self: LiteralString, __iterable: Iterable[LiteralString]) -> LiteralString: ...
+    @overload
     def join(self, __iterable: Iterable[str]) -> str: ...  # type: ignore[misc]
+    @overload
+    def ljust(self: LiteralString, __width: SupportsIndex, __fillchar: LiteralString = " ") -> LiteralString: ...
+    @overload
     def ljust(self, __width: SupportsIndex, __fillchar: str = " ") -> str: ...  # type: ignore[misc]
+    @overload
+    def lower(self: LiteralString) -> LiteralString: ...
+    @overload
     def lower(self) -> str: ...  # type: ignore[misc]
+    @overload
+    def lstrip(self: LiteralString, __chars: LiteralString | None = None) -> LiteralString: ...
+    @overload
     def lstrip(self, __chars: str | None = None) -> str: ...  # type: ignore[misc]
+    @overload
+    def partition(self: LiteralString, __sep: LiteralString) -> tuple[LiteralString, LiteralString, LiteralString]: ...
+    @overload
     def partition(self, __sep: str) -> tuple[str, str, str]: ...  # type: ignore[misc]
+    @overload
+    def replace(
+        self: LiteralString, __old: LiteralString, __new: LiteralString, __count: SupportsIndex = -1
+    ) -> LiteralString: ...
+    @overload
     def replace(self, __old: str, __new: str, __count: SupportsIndex = -1) -> str: ...  # type: ignore[misc]
     if sys.version_info >= (3, 9):
+        @overload
+        def removeprefix(self: LiteralString, __prefix: LiteralString) -> LiteralString: ...
+        @overload
         def removeprefix(self, __prefix: str) -> str: ...  # type: ignore[misc]
+        @overload
+        def removesuffix(self: LiteralString, __suffix: LiteralString) -> LiteralString: ...
+        @overload
         def removesuffix(self, __suffix: str) -> str: ...  # type: ignore[misc]
 
     def rfind(self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
     def rindex(self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
+    @overload
+    def rjust(self: LiteralString, __width: SupportsIndex, __fillchar: LiteralString = " ") -> LiteralString: ...
+    @overload
     def rjust(self, __width: SupportsIndex, __fillchar: str = " ") -> str: ...  # type: ignore[misc]
+    @overload
+    def rpartition(self: LiteralString, __sep: LiteralString) -> tuple[LiteralString, LiteralString, LiteralString]: ...
+    @overload
     def rpartition(self, __sep: str) -> tuple[str, str, str]: ...  # type: ignore[misc]
+    @overload
+    def rsplit(self: LiteralString, sep: LiteralString | None = None, maxsplit: SupportsIndex = -1) -> list[LiteralString]: ...
+    @overload
     def rsplit(self, sep: str | None = None, maxsplit: SupportsIndex = -1) -> list[str]: ...  # type: ignore[misc]
+    @overload
+    def rstrip(self: LiteralString, __chars: LiteralString | None = None) -> LiteralString: ...
+    @overload
     def rstrip(self, __chars: str | None = None) -> str: ...  # type: ignore[misc]
+    @overload
+    def split(self: LiteralString, sep: LiteralString | None = None, maxsplit: SupportsIndex = -1) -> list[LiteralString]: ...
+    @overload
     def split(self, sep: str | None = None, maxsplit: SupportsIndex = -1) -> list[str]: ...  # type: ignore[misc]
+    @overload
+    def splitlines(self: LiteralString, keepends: bool = False) -> list[LiteralString]: ...
+    @overload
     def splitlines(self, keepends: bool = False) -> list[str]: ...  # type: ignore[misc]
     def startswith(
         self, __prefix: str | tuple[str, ...], __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...
     ) -> bool: ...
+    @overload
+    def strip(self: LiteralString, __chars: LiteralString | None = None) -> LiteralString: ...
+    @overload
     def strip(self, __chars: str | None = None) -> str: ...  # type: ignore[misc]
+    @overload
+    def swapcase(self: LiteralString) -> LiteralString: ...
+    @overload
     def swapcase(self) -> str: ...  # type: ignore[misc]
+    @overload
+    def title(self: LiteralString) -> LiteralString: ...
+    @overload
     def title(self) -> str: ...  # type: ignore[misc]
     def translate(self, __table: _TranslateTable) -> str: ...
+    @overload
+    def upper(self: LiteralString) -> LiteralString: ...
+    @overload
     def upper(self) -> str: ...  # type: ignore[misc]
+    @overload
+    def zfill(self: LiteralString, __width: SupportsIndex) -> LiteralString: ...
+    @overload
     def zfill(self, __width: SupportsIndex) -> str: ...  # type: ignore[misc]
     @staticmethod
     @overload
@@ -497,6 +575,9 @@ class str(Sequence[str]):
     @staticmethod
     @overload
     def maketrans(__x: str, __y: str, __z: str) -> dict[int, int | None]: ...
+    @overload
+    def __add__(self: LiteralString, __value: LiteralString) -> LiteralString: ...
+    @overload
     def __add__(self, __value: str) -> str: ...  # type: ignore[misc]
     # Incompatible with Sequence.__contains__
     def __contains__(self, __key: str) -> bool: ...  # type: ignore[override]
@@ -504,13 +585,25 @@ class str(Sequence[str]):
     def __ge__(self, __value: str) -> bool: ...
     def __getitem__(self, __key: SupportsIndex | slice) -> str: ...
     def __gt__(self, __value: str) -> bool: ...
+    @overload
+    def __iter__(self: LiteralString) -> Iterator[LiteralString]: ...
+    @overload
     def __iter__(self) -> Iterator[str]: ...  # type: ignore[misc]
     def __le__(self, __value: str) -> bool: ...
     def __len__(self) -> int: ...
     def __lt__(self, __value: str) -> bool: ...
-    def __mod__(self, __value: Any) -> str: ...  # type: ignore
+    @overload
+    def __mod__(self: LiteralString, __value: LiteralString | tuple[LiteralString, ...]) -> LiteralString: ...
+    @overload
+    def __mod__(self, __value: Any) -> str: ...
+    @overload
+    def __mul__(self: LiteralString, __value: SupportsIndex) -> LiteralString: ...
+    @overload
     def __mul__(self, __value: SupportsIndex) -> str: ...  # type: ignore[misc]
     def __ne__(self, __value: object) -> bool: ...
+    @overload
+    def __rmul__(self: LiteralString, __value: SupportsIndex) -> LiteralString: ...
+    @overload
     def __rmul__(self, __value: SupportsIndex) -> str: ...  # type: ignore[misc]
     def __getnewargs__(self) -> tuple[str]: ...
 
@@ -1665,11 +1758,11 @@ _SupportsSumNoDefaultT = TypeVar("_SupportsSumNoDefaultT", bound=_SupportsSumWit
 # Instead, we special-case the most common examples of this: bool and literal integers.
 if sys.version_info >= (3, 8):
     @overload
-    def sum(__iterable: Iterable[bool], start: int = 0) -> int: ...  # type: ignore[misc]
+    def sum(__iterable: Iterable[bool | _LiteralInteger], start: int = 0) -> int: ...  # type: ignore[misc]
 
 else:
     @overload
-    def sum(__iterable: Iterable[bool], __start: int = 0) -> int: ...  # type: ignore[misc]
+    def sum(__iterable: Iterable[bool | _LiteralInteger], __start: int = 0) -> int: ...  # type: ignore[misc]
 
 @overload
 def sum(__iterable: Iterable[_SupportsSumNoDefaultT]) -> _SupportsSumNoDefaultT | Literal[0]: ...
diff --git a/mypy/typeshed/stdlib/codecs.pyi b/mypy/typeshed/stdlib/codecs.pyi
index 3f6d2d3d16b7c..c9b6a4a82da63 100644
--- a/mypy/typeshed/stdlib/codecs.pyi
+++ b/mypy/typeshed/stdlib/codecs.pyi
@@ -96,6 +96,7 @@ class _IncrementalDecoder(Protocol):
     def __call__(self, errors: str = ...) -> IncrementalDecoder: ...
 
 class CodecInfo(tuple[_Encoder, _Decoder, _StreamReader, _StreamWriter]):
+    _is_text_encoding: bool
     @property
     def encode(self) -> _Encoder: ...
     @property
diff --git a/mypy/typeshed/stdlib/collections/__init__.pyi b/mypy/typeshed/stdlib/collections/__init__.pyi
index d5ca17c749eb7..e56baf8b52c95 100644
--- a/mypy/typeshed/stdlib/collections/__init__.pyi
+++ b/mypy/typeshed/stdlib/collections/__init__.pyi
@@ -1,6 +1,6 @@
 import sys
 from _collections_abc import dict_items, dict_keys, dict_values
-from _typeshed import SupportsKeysAndGetItem, SupportsRichComparison, SupportsRichComparisonT
+from _typeshed import SupportsItems, SupportsKeysAndGetItem, SupportsRichComparison, SupportsRichComparisonT
 from typing import Any, Generic, NoReturn, TypeVar, overload
 from typing_extensions import Self, SupportsIndex, final
 
@@ -299,10 +299,10 @@ class Counter(dict[_T, int], Generic[_T]):
     def __pos__(self) -> Counter[_T]: ...
     def __neg__(self) -> Counter[_T]: ...
     # several type: ignores because __iadd__ is supposedly incompatible with __add__, etc.
-    def __iadd__(self, other: Counter[_T]) -> Self: ...  # type: ignore[misc]
-    def __isub__(self, other: Counter[_T]) -> Self: ...
-    def __iand__(self, other: Counter[_T]) -> Self: ...
-    def __ior__(self, other: Counter[_T]) -> Self: ...  # type: ignore[override,misc]
+    def __iadd__(self, other: SupportsItems[_T, int]) -> Self: ...  # type: ignore[misc]
+    def __isub__(self, other: SupportsItems[_T, int]) -> Self: ...
+    def __iand__(self, other: SupportsItems[_T, int]) -> Self: ...
+    def __ior__(self, other: SupportsItems[_T, int]) -> Self: ...  # type: ignore[override,misc]
     if sys.version_info >= (3, 10):
         def total(self) -> int: ...
         def __le__(self, other: Counter[Any]) -> bool: ...
diff --git a/mypy/typeshed/stdlib/email/utils.pyi b/mypy/typeshed/stdlib/email/utils.pyi
index 090ddf9e31bc8..ed63b6b323127 100644
--- a/mypy/typeshed/stdlib/email/utils.pyi
+++ b/mypy/typeshed/stdlib/email/utils.pyi
@@ -1,5 +1,6 @@
 import datetime
 import sys
+from _typeshed import Unused
 from email import _ParamType
 from email.charset import Charset
 from typing import overload
@@ -51,7 +52,13 @@ else:
 def mktime_tz(data: _PDTZ) -> int: ...
 def formatdate(timeval: float | None = None, localtime: bool = False, usegmt: bool = False) -> str: ...
 def format_datetime(dt: datetime.datetime, usegmt: bool = False) -> str: ...
-def localtime(dt: datetime.datetime | None = None, isdst: int = -1) -> datetime.datetime: ...
+
+if sys.version_info >= (3, 12):
+    def localtime(dt: datetime.datetime | None = None, isdst: Unused = None) -> datetime.datetime: ...
+
+else:
+    def localtime(dt: datetime.datetime | None = None, isdst: int = -1) -> datetime.datetime: ...
+
 def make_msgid(idstring: str | None = None, domain: str | None = None) -> str: ...
 def decode_rfc2231(s: str) -> tuple[str | None, str | None, str]: ...
 def encode_rfc2231(s: str, charset: str | None = None, language: str | None = None) -> str: ...
diff --git a/mypy/typeshed/stdlib/enum.pyi b/mypy/typeshed/stdlib/enum.pyi
index 383c336ed2c79..96a96dbce10e7 100644
--- a/mypy/typeshed/stdlib/enum.pyi
+++ b/mypy/typeshed/stdlib/enum.pyi
@@ -4,7 +4,7 @@ import types
 from _typeshed import SupportsKeysAndGetItem, Unused
 from abc import ABCMeta
 from builtins import property as _builtins_property
-from collections.abc import Iterable, Iterator, Mapping
+from collections.abc import Callable, Iterable, Iterator, Mapping
 from typing import Any, Generic, TypeVar, overload
 from typing_extensions import Literal, Self, TypeAlias
 
@@ -34,6 +34,9 @@ if sys.version_info >= (3, 11):
         "verify",
     ]
 
+if sys.version_info >= (3, 12):
+    __all__ += ["pickle_by_enum_name", "pickle_by_global_name"]
+
 _EnumMemberT = TypeVar("_EnumMemberT")
 _EnumerationT = TypeVar("_EnumerationT", bound=type[Enum])
 
@@ -234,6 +237,8 @@ if sys.version_info >= (3, 11):
         _value_: str
         @_magic_enum_attr
         def value(self) -> str: ...
+        @staticmethod
+        def _generate_next_value_(name: str, start: int, count: int, last_values: list[str]) -> str: ...
 
     class EnumCheck(StrEnum):
         CONTINUOUS: str
@@ -289,3 +294,7 @@ class auto(IntFlag):
     @_magic_enum_attr
     def value(self) -> Any: ...
     def __new__(cls) -> Self: ...
+
+if sys.version_info >= (3, 12):
+    def pickle_by_global_name(self: Enum, proto: int) -> str: ...
+    def pickle_by_enum_name(self: _EnumMemberT, proto: int) -> tuple[Callable[..., Any], tuple[type[_EnumMemberT], str]]: ...
diff --git a/mypy/typeshed/stdlib/functools.pyi b/mypy/typeshed/stdlib/functools.pyi
index 1b4e59b7c1204..8adc3d82292e2 100644
--- a/mypy/typeshed/stdlib/functools.pyi
+++ b/mypy/typeshed/stdlib/functools.pyi
@@ -1,9 +1,9 @@
 import sys
 import types
-from _typeshed import IdentityFunction, SupportsAllComparisons, SupportsItems
+from _typeshed import SupportsAllComparisons, SupportsItems
 from collections.abc import Callable, Hashable, Iterable, Sequence, Sized
 from typing import Any, Generic, NamedTuple, TypeVar, overload
-from typing_extensions import Literal, Self, TypeAlias, TypedDict, final
+from typing_extensions import Literal, ParamSpec, Self, TypeAlias, TypedDict, final
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -28,10 +28,12 @@ if sys.version_info >= (3, 8):
 if sys.version_info >= (3, 9):
     __all__ += ["cache"]
 
-_AnyCallable: TypeAlias = Callable[..., object]
-
 _T = TypeVar("_T")
 _S = TypeVar("_S")
+_PWrapped = ParamSpec("_PWrapped")
+_RWrapped = TypeVar("_RWrapped")
+_PWrapper = ParamSpec("_PWrapper")
+_RWapper = TypeVar("_RWapper")
 
 @overload
 def reduce(function: Callable[[_T, _S], _T], sequence: Iterable[_S], initial: _T) -> _T: ...
@@ -85,31 +87,41 @@ else:
     ]
 WRAPPER_UPDATES: tuple[Literal["__dict__"]]
 
+class _Wrapped(Generic[_PWrapped, _RWrapped, _PWrapper, _RWapper]):
+    __wrapped__: Callable[_PWrapped, _RWrapped]
+    def __call__(self, *args: _PWrapper.args, **kwargs: _PWrapper.kwargs) -> _RWapper: ...
+    # as with ``Callable``, we'll assume that these attributes exist
+    __name__: str
+    __qualname__: str
+
+class _Wrapper(Generic[_PWrapped, _RWrapped]):
+    def __call__(self, f: Callable[_PWrapper, _RWapper]) -> _Wrapped[_PWrapped, _RWrapped, _PWrapper, _RWapper]: ...
+
 if sys.version_info >= (3, 12):
     def update_wrapper(
-        wrapper: _T,
-        wrapped: _AnyCallable,
+        wrapper: Callable[_PWrapper, _RWapper],
+        wrapped: Callable[_PWrapped, _RWrapped],
         assigned: Sequence[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__", "__type_params__"),
         updated: Sequence[str] = ("__dict__",),
-    ) -> _T: ...
+    ) -> _Wrapped[_PWrapped, _RWrapped, _PWrapper, _RWapper]: ...
     def wraps(
-        wrapped: _AnyCallable,
+        wrapped: Callable[_PWrapped, _RWrapped],
         assigned: Sequence[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__", "__type_params__"),
         updated: Sequence[str] = ("__dict__",),
-    ) -> IdentityFunction: ...
+    ) -> _Wrapper[_PWrapped, _RWrapped]: ...
 
 else:
     def update_wrapper(
-        wrapper: _T,
-        wrapped: _AnyCallable,
+        wrapper: Callable[_PWrapper, _RWapper],
+        wrapped: Callable[_PWrapped, _RWrapped],
         assigned: Sequence[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__"),
         updated: Sequence[str] = ("__dict__",),
-    ) -> _T: ...
+    ) -> _Wrapped[_PWrapped, _RWrapped, _PWrapper, _RWapper]: ...
     def wraps(
-        wrapped: _AnyCallable,
+        wrapped: Callable[_PWrapped, _RWrapped],
         assigned: Sequence[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__"),
         updated: Sequence[str] = ("__dict__",),
-    ) -> IdentityFunction: ...
+    ) -> _Wrapper[_PWrapped, _RWrapped]: ...
 
 def total_ordering(cls: type[_T]) -> type[_T]: ...
 def cmp_to_key(mycmp: Callable[[_T, _T], int]) -> Callable[[_T], SupportsAllComparisons]: ...
diff --git a/mypy/typeshed/stdlib/http/client.pyi b/mypy/typeshed/stdlib/http/client.pyi
index 9c7c0c1c4a122..41ece1b050b8d 100644
--- a/mypy/typeshed/stdlib/http/client.pyi
+++ b/mypy/typeshed/stdlib/http/client.pyi
@@ -1,6 +1,7 @@
 import email.message
 import io
 import ssl
+import sys
 import types
 from _typeshed import ReadableBuffer, SupportsRead, WriteableBuffer
 from collections.abc import Callable, Iterable, Iterator, Mapping
@@ -175,19 +176,31 @@ class HTTPConnection:
 class HTTPSConnection(HTTPConnection):
     # Can be `None` if `.connect()` was not called:
     sock: ssl.SSLSocket | Any
-    def __init__(
-        self,
-        host: str,
-        port: int | None = None,
-        key_file: str | None = None,
-        cert_file: str | None = None,
-        timeout: float | None = ...,
-        source_address: tuple[str, int] | None = None,
-        *,
-        context: ssl.SSLContext | None = None,
-        check_hostname: bool | None = None,
-        blocksize: int = 8192,
-    ) -> None: ...
+    if sys.version_info >= (3, 12):
+        def __init__(
+            self,
+            host: str,
+            port: str | None = None,
+            *,
+            timeout: float | None = ...,
+            source_address: tuple[str, int] | None = None,
+            context: ssl.SSLContext | None = None,
+            blocksize: int = 8192,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            host: str,
+            port: int | None = None,
+            key_file: str | None = None,
+            cert_file: str | None = None,
+            timeout: float | None = ...,
+            source_address: tuple[str, int] | None = None,
+            *,
+            context: ssl.SSLContext | None = None,
+            check_hostname: bool | None = None,
+            blocksize: int = 8192,
+        ) -> None: ...
 
 class HTTPException(Exception): ...
 
diff --git a/mypy/typeshed/stdlib/inspect.pyi b/mypy/typeshed/stdlib/inspect.pyi
index 2d004a8e6b573..9af4c39bae9e2 100644
--- a/mypy/typeshed/stdlib/inspect.pyi
+++ b/mypy/typeshed/stdlib/inspect.pyi
@@ -2,6 +2,7 @@ import dis
 import enum
 import sys
 import types
+from _typeshed import StrPath
 from collections import OrderedDict
 from collections.abc import AsyncGenerator, Awaitable, Callable, Coroutine, Generator, Mapping, Sequence, Set as AbstractSet
 from types import (
@@ -127,8 +128,21 @@ if sys.version_info >= (3, 11):
         "walktree",
     ]
 
+    if sys.version_info >= (3, 12):
+        __all__ += [
+            "markcoroutinefunction",
+            "AGEN_CLOSED",
+            "AGEN_CREATED",
+            "AGEN_RUNNING",
+            "AGEN_SUSPENDED",
+            "getasyncgenlocals",
+            "getasyncgenstate",
+            "BufferFlags",
+        ]
+
 _P = ParamSpec("_P")
 _T = TypeVar("_T")
+_F = TypeVar("_F", bound=Callable[..., Any])
 _T_cont = TypeVar("_T_cont", contravariant=True)
 _V_cont = TypeVar("_V_cont", contravariant=True)
 
@@ -177,12 +191,15 @@ if sys.version_info >= (3, 11):
     @overload
     def getmembers_static(object: object, predicate: _GetMembersPredicate | None = None) -> _GetMembersReturn: ...
 
-def getmodulename(path: str) -> str | None: ...
+def getmodulename(path: StrPath) -> str | None: ...
 def ismodule(object: object) -> TypeGuard[ModuleType]: ...
 def isclass(object: object) -> TypeGuard[type[Any]]: ...
 def ismethod(object: object) -> TypeGuard[MethodType]: ...
 def isfunction(object: object) -> TypeGuard[FunctionType]: ...
 
+if sys.version_info >= (3, 12):
+    def markcoroutinefunction(func: _F) -> _F: ...
+
 if sys.version_info >= (3, 8):
     @overload
     def isgeneratorfunction(obj: Callable[..., Generator[Any, Any, Any]]) -> bool: ...
@@ -359,6 +376,17 @@ class _ParameterKind(enum.IntEnum):
         @property
         def description(self) -> str: ...
 
+if sys.version_info >= (3, 12):
+    AGEN_CREATED: Literal["AGEN_CREATED"]
+    AGEN_RUNNING: Literal["AGEN_RUNNING"]
+    AGEN_SUSPENDED: Literal["AGEN_SUSPENDED"]
+    AGEN_CLOSED: Literal["AGEN_CLOSED"]
+
+    def getasyncgenstate(
+        agen: AsyncGenerator[Any, Any]
+    ) -> Literal["AGEN_CREATED", "AGEN_RUNNING", "AGEN_SUSPENDED", "AGEN_CLOSED"]: ...
+    def getasyncgenlocals(agen: AsyncGeneratorType[Any, Any]) -> dict[str, Any]: ...
+
 class Parameter:
     def __init__(self, name: str, kind: _ParameterKind, *, default: Any = ..., annotation: Any = ...) -> None: ...
     empty = _empty
diff --git a/mypy/typeshed/stdlib/pydoc.pyi b/mypy/typeshed/stdlib/pydoc.pyi
index ed97f1918e019..c993af390bbb2 100644
--- a/mypy/typeshed/stdlib/pydoc.pyi
+++ b/mypy/typeshed/stdlib/pydoc.pyi
@@ -195,12 +195,24 @@ def resolve(thing: str | object, forceload: bool = ...) -> tuple[object, str] |
 def render_doc(
     thing: str | object, title: str = "Python Library Documentation: %s", forceload: bool = ..., renderer: Doc | None = None
 ) -> str: ...
-def doc(
-    thing: str | object,
-    title: str = "Python Library Documentation: %s",
-    forceload: bool = ...,
-    output: SupportsWrite[str] | None = None,
-) -> None: ...
+
+if sys.version_info >= (3, 12):
+    def doc(
+        thing: str | object,
+        title: str = "Python Library Documentation: %s",
+        forceload: bool = ...,
+        output: SupportsWrite[str] | None = None,
+        is_cli: bool = False,
+    ) -> None: ...
+
+else:
+    def doc(
+        thing: str | object,
+        title: str = "Python Library Documentation: %s",
+        forceload: bool = ...,
+        output: SupportsWrite[str] | None = None,
+    ) -> None: ...
+
 def writedoc(thing: str | object, forceload: bool = ...) -> None: ...
 def writedocs(dir: str, pkgpath: str = "", done: Any | None = None) -> None: ...
 
@@ -216,7 +228,11 @@ class Helper:
     def __call__(self, request: str | Helper | object = ...) -> None: ...
     def interact(self) -> None: ...
     def getline(self, prompt: str) -> str: ...
-    def help(self, request: Any) -> None: ...
+    if sys.version_info >= (3, 12):
+        def help(self, request: Any, is_cli: bool = False) -> None: ...
+    else:
+        def help(self, request: Any) -> None: ...
+
     def intro(self) -> None: ...
     def list(self, items: _list[str], columns: int = 4, width: int = 80) -> None: ...
     def listkeywords(self) -> None: ...
diff --git a/mypy/typeshed/stdlib/socket.pyi b/mypy/typeshed/stdlib/socket.pyi
index e1ffc573b52e4..5dd92ec8e1161 100644
--- a/mypy/typeshed/stdlib/socket.pyi
+++ b/mypy/typeshed/stdlib/socket.pyi
@@ -468,6 +468,8 @@ if sys.version_info >= (3, 12):
             ETHERTYPE_IPV6 as ETHERTYPE_IPV6,
             ETHERTYPE_VLAN as ETHERTYPE_VLAN,
         )
+if sys.version_info >= (3, 11) and sys.platform == "darwin":
+    from _socket import TCP_CONNECTION_INFO as TCP_CONNECTION_INFO
 
 # Re-exported from errno
 EBADF: int
diff --git a/mypy/typeshed/stdlib/tempfile.pyi b/mypy/typeshed/stdlib/tempfile.pyi
index b251f8b9d0290..ea04303683b5f 100644
--- a/mypy/typeshed/stdlib/tempfile.pyi
+++ b/mypy/typeshed/stdlib/tempfile.pyi
@@ -380,6 +380,7 @@ else:
 # It does not actually derive from IO[AnyStr], but it does mostly behave
 # like one.
 class SpooledTemporaryFile(IO[AnyStr], _SpooledTemporaryFileBase):
+    _file: IO[AnyStr]
     @property
     def encoding(self) -> str: ...  # undocumented
     @property
diff --git a/mypy/typeshed/stdlib/types.pyi b/mypy/typeshed/stdlib/types.pyi
index 6909c765cb7d6..e5468ce4ed3c9 100644
--- a/mypy/typeshed/stdlib/types.pyi
+++ b/mypy/typeshed/stdlib/types.pyi
@@ -17,7 +17,7 @@ from importlib.machinery import ModuleSpec
 
 # pytype crashes if types.MappingProxyType inherits from collections.abc.Mapping instead of typing.Mapping
 from typing import Any, ClassVar, Generic, Mapping, Protocol, TypeVar, overload  # noqa: Y022
-from typing_extensions import Literal, ParamSpec, TypeVarTuple, final
+from typing_extensions import Literal, ParamSpec, Self, TypeVarTuple, final
 
 __all__ = [
     "FunctionType",
@@ -63,11 +63,8 @@ if sys.version_info >= (3, 12):
 
 _T1 = TypeVar("_T1")
 _T2 = TypeVar("_T2")
-_T_co = TypeVar("_T_co", covariant=True)
-_T_contra = TypeVar("_T_contra", contravariant=True)
 _KT = TypeVar("_KT")
 _VT_co = TypeVar("_VT_co", covariant=True)
-_V_co = TypeVar("_V_co", covariant=True)
 
 @final
 class _Cell:
@@ -351,27 +348,31 @@ class ModuleType:
     # using `builtins.__import__` or `importlib.import_module` less painful
     def __getattr__(self, name: str) -> Any: ...
 
+_YieldT_co = TypeVar("_YieldT_co", covariant=True)
+_SendT_contra = TypeVar("_SendT_contra", contravariant=True)
+_ReturnT_co = TypeVar("_ReturnT_co", covariant=True)
+
 @final
-class GeneratorType(Generator[_T_co, _T_contra, _V_co]):
+class GeneratorType(Generator[_YieldT_co, _SendT_contra, _ReturnT_co]):
     @property
-    def gi_yieldfrom(self) -> GeneratorType[_T_co, _T_contra, Any] | None: ...
+    def gi_yieldfrom(self) -> GeneratorType[_YieldT_co, _SendT_contra, Any] | None: ...
     if sys.version_info >= (3, 11):
         @property
         def gi_suspended(self) -> bool: ...
     __name__: str
     __qualname__: str
-    def __iter__(self) -> GeneratorType[_T_co, _T_contra, _V_co]: ...
-    def __next__(self) -> _T_co: ...
-    def send(self, __arg: _T_contra) -> _T_co: ...
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> _YieldT_co: ...
+    def send(self, __arg: _SendT_contra) -> _YieldT_co: ...
     @overload
     def throw(
         self, __typ: type[BaseException], __val: BaseException | object = ..., __tb: TracebackType | None = ...
-    ) -> _T_co: ...
+    ) -> _YieldT_co: ...
     @overload
-    def throw(self, __typ: BaseException, __val: None = None, __tb: TracebackType | None = ...) -> _T_co: ...
+    def throw(self, __typ: BaseException, __val: None = None, __tb: TracebackType | None = ...) -> _YieldT_co: ...
 
 @final
-class AsyncGeneratorType(AsyncGenerator[_T_co, _T_contra]):
+class AsyncGeneratorType(AsyncGenerator[_YieldT_co, _SendT_contra]):
     @property
     def ag_await(self) -> Awaitable[Any] | None: ...
     __name__: str
@@ -380,21 +381,21 @@ class AsyncGeneratorType(AsyncGenerator[_T_co, _T_contra]):
         @property
         def ag_suspended(self) -> bool: ...
 
-    def __aiter__(self) -> AsyncGeneratorType[_T_co, _T_contra]: ...
-    def __anext__(self) -> Coroutine[Any, Any, _T_co]: ...
-    def asend(self, __val: _T_contra) -> Coroutine[Any, Any, _T_co]: ...
+    def __aiter__(self) -> Self: ...
+    def __anext__(self) -> Coroutine[Any, Any, _YieldT_co]: ...
+    def asend(self, __val: _SendT_contra) -> Coroutine[Any, Any, _YieldT_co]: ...
     @overload
     async def athrow(
         self, __typ: type[BaseException], __val: BaseException | object = ..., __tb: TracebackType | None = ...
-    ) -> _T_co: ...
+    ) -> _YieldT_co: ...
     @overload
-    async def athrow(self, __typ: BaseException, __val: None = None, __tb: TracebackType | None = ...) -> _T_co: ...
+    async def athrow(self, __typ: BaseException, __val: None = None, __tb: TracebackType | None = ...) -> _YieldT_co: ...
     def aclose(self) -> Coroutine[Any, Any, None]: ...
     if sys.version_info >= (3, 9):
         def __class_getitem__(cls, __item: Any) -> GenericAlias: ...
 
 @final
-class CoroutineType(Coroutine[_T_co, _T_contra, _V_co]):
+class CoroutineType(Coroutine[_YieldT_co, _SendT_contra, _ReturnT_co]):
     __name__: str
     __qualname__: str
     @property
@@ -404,14 +405,14 @@ class CoroutineType(Coroutine[_T_co, _T_contra, _V_co]):
         def cr_suspended(self) -> bool: ...
 
     def close(self) -> None: ...
-    def __await__(self) -> Generator[Any, None, _V_co]: ...
-    def send(self, __arg: _T_contra) -> _T_co: ...
+    def __await__(self) -> Generator[Any, None, _ReturnT_co]: ...
+    def send(self, __arg: _SendT_contra) -> _YieldT_co: ...
     @overload
     def throw(
         self, __typ: type[BaseException], __val: BaseException | object = ..., __tb: TracebackType | None = ...
-    ) -> _T_co: ...
+    ) -> _YieldT_co: ...
     @overload
-    def throw(self, __typ: BaseException, __val: None = None, __tb: TracebackType | None = ...) -> _T_co: ...
+    def throw(self, __typ: BaseException, __val: None = None, __tb: TracebackType | None = ...) -> _YieldT_co: ...
 
 class _StaticFunctionType:
     # Fictional type to correct the type of MethodType.__func__.
diff --git a/mypy/typeshed/stdlib/typing.pyi b/mypy/typeshed/stdlib/typing.pyi
index 08d7da5e86225..2c5f820ea3657 100644
--- a/mypy/typeshed/stdlib/typing.pyi
+++ b/mypy/typeshed/stdlib/typing.pyi
@@ -289,10 +289,8 @@ _S = TypeVar("_S")
 _KT = TypeVar("_KT")  # Key type.
 _VT = TypeVar("_VT")  # Value type.
 _T_co = TypeVar("_T_co", covariant=True)  # Any type covariant containers.
-_V_co = TypeVar("_V_co", covariant=True)  # Any type covariant containers.
 _KT_co = TypeVar("_KT_co", covariant=True)  # Key type covariant containers.
 _VT_co = TypeVar("_VT_co", covariant=True)  # Value type covariant containers.
-_T_contra = TypeVar("_T_contra", contravariant=True)  # Ditto contravariant.
 _TC = TypeVar("_TC", bound=Type[object])
 
 def no_type_check(arg: _F) -> _F: ...
@@ -397,20 +395,24 @@ class Reversible(Iterable[_T_co], Protocol[_T_co]):
     @abstractmethod
     def __reversed__(self) -> Iterator[_T_co]: ...
 
-class Generator(Iterator[_T_co], Generic[_T_co, _T_contra, _V_co]):
-    def __next__(self) -> _T_co: ...
+_YieldT_co = TypeVar("_YieldT_co", covariant=True)
+_SendT_contra = TypeVar("_SendT_contra", contravariant=True)
+_ReturnT_co = TypeVar("_ReturnT_co", covariant=True)
+
+class Generator(Iterator[_YieldT_co], Generic[_YieldT_co, _SendT_contra, _ReturnT_co]):
+    def __next__(self) -> _YieldT_co: ...
     @abstractmethod
-    def send(self, __value: _T_contra) -> _T_co: ...
+    def send(self, __value: _SendT_contra) -> _YieldT_co: ...
     @overload
     @abstractmethod
     def throw(
         self, __typ: Type[BaseException], __val: BaseException | object = None, __tb: TracebackType | None = None
-    ) -> _T_co: ...
+    ) -> _YieldT_co: ...
     @overload
     @abstractmethod
-    def throw(self, __typ: BaseException, __val: None = None, __tb: TracebackType | None = None) -> _T_co: ...
+    def throw(self, __typ: BaseException, __val: None = None, __tb: TracebackType | None = None) -> _YieldT_co: ...
     def close(self) -> None: ...
-    def __iter__(self) -> Generator[_T_co, _T_contra, _V_co]: ...
+    def __iter__(self) -> Generator[_YieldT_co, _SendT_contra, _ReturnT_co]: ...
     @property
     def gi_code(self) -> CodeType: ...
     @property
@@ -425,7 +427,7 @@ class Awaitable(Protocol[_T_co]):
     @abstractmethod
     def __await__(self) -> Generator[Any, None, _T_co]: ...
 
-class Coroutine(Awaitable[_V_co], Generic[_T_co, _T_contra, _V_co]):
+class Coroutine(Awaitable[_ReturnT_co], Generic[_YieldT_co, _SendT_contra, _ReturnT_co]):
     __name__: str
     __qualname__: str
     @property
@@ -437,15 +439,15 @@ class Coroutine(Awaitable[_V_co], Generic[_T_co, _T_contra, _V_co]):
     @property
     def cr_running(self) -> bool: ...
     @abstractmethod
-    def send(self, __value: _T_contra) -> _T_co: ...
+    def send(self, __value: _SendT_contra) -> _YieldT_co: ...
     @overload
     @abstractmethod
     def throw(
         self, __typ: Type[BaseException], __val: BaseException | object = None, __tb: TracebackType | None = None
-    ) -> _T_co: ...
+    ) -> _YieldT_co: ...
     @overload
     @abstractmethod
-    def throw(self, __typ: BaseException, __val: None = None, __tb: TracebackType | None = None) -> _T_co: ...
+    def throw(self, __typ: BaseException, __val: None = None, __tb: TracebackType | None = None) -> _YieldT_co: ...
     @abstractmethod
     def close(self) -> None: ...
 
@@ -453,7 +455,10 @@ class Coroutine(Awaitable[_V_co], Generic[_T_co, _T_contra, _V_co]):
 # The parameters correspond to Generator, but the 4th is the original type.
 @type_check_only
 class AwaitableGenerator(
-    Awaitable[_V_co], Generator[_T_co, _T_contra, _V_co], Generic[_T_co, _T_contra, _V_co, _S], metaclass=ABCMeta
+    Awaitable[_ReturnT_co],
+    Generator[_YieldT_co, _SendT_contra, _ReturnT_co],
+    Generic[_YieldT_co, _SendT_contra, _ReturnT_co, _S],
+    metaclass=ABCMeta,
 ): ...
 
 @runtime_checkable
@@ -467,18 +472,18 @@ class AsyncIterator(AsyncIterable[_T_co], Protocol[_T_co]):
     def __anext__(self) -> Awaitable[_T_co]: ...
     def __aiter__(self) -> AsyncIterator[_T_co]: ...
 
-class AsyncGenerator(AsyncIterator[_T_co], Generic[_T_co, _T_contra]):
-    def __anext__(self) -> Awaitable[_T_co]: ...
+class AsyncGenerator(AsyncIterator[_YieldT_co], Generic[_YieldT_co, _SendT_contra]):
+    def __anext__(self) -> Awaitable[_YieldT_co]: ...
     @abstractmethod
-    def asend(self, __value: _T_contra) -> Awaitable[_T_co]: ...
+    def asend(self, __value: _SendT_contra) -> Awaitable[_YieldT_co]: ...
     @overload
     @abstractmethod
     def athrow(
         self, __typ: Type[BaseException], __val: BaseException | object = None, __tb: TracebackType | None = None
-    ) -> Awaitable[_T_co]: ...
+    ) -> Awaitable[_YieldT_co]: ...
     @overload
     @abstractmethod
-    def athrow(self, __typ: BaseException, __val: None = None, __tb: TracebackType | None = None) -> Awaitable[_T_co]: ...
+    def athrow(self, __typ: BaseException, __val: None = None, __tb: TracebackType | None = None) -> Awaitable[_YieldT_co]: ...
     def aclose(self) -> Awaitable[None]: ...
     @property
     def ag_await(self) -> Any: ...
diff --git a/mypy/typeshed/stdlib/unittest/mock.pyi b/mypy/typeshed/stdlib/unittest/mock.pyi
index 1f554da52d5d1..0ed0701cc450e 100644
--- a/mypy/typeshed/stdlib/unittest/mock.pyi
+++ b/mypy/typeshed/stdlib/unittest/mock.pyi
@@ -3,13 +3,14 @@ from collections.abc import Awaitable, Callable, Coroutine, Iterable, Mapping, S
 from contextlib import _GeneratorContextManager
 from types import TracebackType
 from typing import Any, Generic, TypeVar, overload
-from typing_extensions import Final, Literal, Self, TypeAlias
+from typing_extensions import Final, Literal, ParamSpec, Self, TypeAlias
 
 _T = TypeVar("_T")
 _TT = TypeVar("_TT", bound=type[Any])
 _R = TypeVar("_R")
 _F = TypeVar("_F", bound=Callable[..., Any])
 _AF = TypeVar("_AF", bound=Callable[..., Coroutine[Any, Any, Any]])
+_P = ParamSpec("_P")
 
 if sys.version_info >= (3, 8):
     __all__ = (
@@ -234,7 +235,7 @@ class _patch(Generic[_T]):
     @overload
     def __call__(self, func: _TT) -> _TT: ...
     @overload
-    def __call__(self, func: Callable[..., _R]) -> Callable[..., _R]: ...
+    def __call__(self, func: Callable[_P, _R]) -> Callable[_P, _R]: ...
     if sys.version_info >= (3, 8):
         def decoration_helper(
             self, patched: _patch[Any], args: Sequence[Any], keywargs: Any

From 9f4c0d8af2c0542f749563535de2c28da736a9a7 Mon Sep 17 00:00:00 2001
From: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
Date: Mon, 26 Sep 2022 12:55:07 -0700
Subject: [PATCH 109/129] Remove use of LiteralString in builtins (#13743)

---
 mypy/typeshed/stdlib/builtins.pyi | 93 -------------------------------
 1 file changed, 93 deletions(-)

diff --git a/mypy/typeshed/stdlib/builtins.pyi b/mypy/typeshed/stdlib/builtins.pyi
index 45a17b33d979e..58669c9b45002 100644
--- a/mypy/typeshed/stdlib/builtins.pyi
+++ b/mypy/typeshed/stdlib/builtins.pyi
@@ -56,7 +56,6 @@ from typing import (  # noqa: Y022
 from typing_extensions import (
     Concatenate,
     Literal,
-    LiteralString,
     ParamSpec,
     Self,
     SupportsIndex,
@@ -433,17 +432,8 @@ class str(Sequence[str]):
     def __new__(cls, object: object = ...) -> Self: ...
     @overload
     def __new__(cls, object: ReadableBuffer, encoding: str = ..., errors: str = ...) -> Self: ...
-    @overload
-    def capitalize(self: LiteralString) -> LiteralString: ...
-    @overload
     def capitalize(self) -> str: ...  # type: ignore[misc]
-    @overload
-    def casefold(self: LiteralString) -> LiteralString: ...
-    @overload
     def casefold(self) -> str: ...  # type: ignore[misc]
-    @overload
-    def center(self: LiteralString, __width: SupportsIndex, __fillchar: LiteralString = " ") -> LiteralString: ...
-    @overload
     def center(self, __width: SupportsIndex, __fillchar: str = " ") -> str: ...  # type: ignore[misc]
     def count(self, x: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
     def encode(self, encoding: str = "utf-8", errors: str = "strict") -> bytes: ...
@@ -451,20 +441,11 @@ class str(Sequence[str]):
         self, __suffix: str | tuple[str, ...], __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...
     ) -> bool: ...
     if sys.version_info >= (3, 8):
-        @overload
-        def expandtabs(self: LiteralString, tabsize: SupportsIndex = 8) -> LiteralString: ...
-        @overload
         def expandtabs(self, tabsize: SupportsIndex = 8) -> str: ...  # type: ignore[misc]
     else:
-        @overload
-        def expandtabs(self: LiteralString, tabsize: int = 8) -> LiteralString: ...
-        @overload
         def expandtabs(self, tabsize: int = 8) -> str: ...  # type: ignore[misc]
 
     def find(self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
-    @overload
-    def format(self: LiteralString, *args: LiteralString, **kwargs: LiteralString) -> LiteralString: ...
-    @overload
     def format(self, *args: object, **kwargs: object) -> str: ...
     def format_map(self, map: _FormatMapMapping) -> str: ...
     def index(self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
@@ -480,91 +461,32 @@ class str(Sequence[str]):
     def isspace(self) -> bool: ...
     def istitle(self) -> bool: ...
     def isupper(self) -> bool: ...
-    @overload
-    def join(self: LiteralString, __iterable: Iterable[LiteralString]) -> LiteralString: ...
-    @overload
     def join(self, __iterable: Iterable[str]) -> str: ...  # type: ignore[misc]
-    @overload
-    def ljust(self: LiteralString, __width: SupportsIndex, __fillchar: LiteralString = " ") -> LiteralString: ...
-    @overload
     def ljust(self, __width: SupportsIndex, __fillchar: str = " ") -> str: ...  # type: ignore[misc]
-    @overload
-    def lower(self: LiteralString) -> LiteralString: ...
-    @overload
     def lower(self) -> str: ...  # type: ignore[misc]
-    @overload
-    def lstrip(self: LiteralString, __chars: LiteralString | None = None) -> LiteralString: ...
-    @overload
     def lstrip(self, __chars: str | None = None) -> str: ...  # type: ignore[misc]
-    @overload
-    def partition(self: LiteralString, __sep: LiteralString) -> tuple[LiteralString, LiteralString, LiteralString]: ...
-    @overload
     def partition(self, __sep: str) -> tuple[str, str, str]: ...  # type: ignore[misc]
-    @overload
-    def replace(
-        self: LiteralString, __old: LiteralString, __new: LiteralString, __count: SupportsIndex = -1
-    ) -> LiteralString: ...
-    @overload
     def replace(self, __old: str, __new: str, __count: SupportsIndex = -1) -> str: ...  # type: ignore[misc]
     if sys.version_info >= (3, 9):
-        @overload
-        def removeprefix(self: LiteralString, __prefix: LiteralString) -> LiteralString: ...
-        @overload
         def removeprefix(self, __prefix: str) -> str: ...  # type: ignore[misc]
-        @overload
-        def removesuffix(self: LiteralString, __suffix: LiteralString) -> LiteralString: ...
-        @overload
         def removesuffix(self, __suffix: str) -> str: ...  # type: ignore[misc]
 
     def rfind(self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
     def rindex(self, __sub: str, __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...) -> int: ...
-    @overload
-    def rjust(self: LiteralString, __width: SupportsIndex, __fillchar: LiteralString = " ") -> LiteralString: ...
-    @overload
     def rjust(self, __width: SupportsIndex, __fillchar: str = " ") -> str: ...  # type: ignore[misc]
-    @overload
-    def rpartition(self: LiteralString, __sep: LiteralString) -> tuple[LiteralString, LiteralString, LiteralString]: ...
-    @overload
     def rpartition(self, __sep: str) -> tuple[str, str, str]: ...  # type: ignore[misc]
-    @overload
-    def rsplit(self: LiteralString, sep: LiteralString | None = None, maxsplit: SupportsIndex = -1) -> list[LiteralString]: ...
-    @overload
     def rsplit(self, sep: str | None = None, maxsplit: SupportsIndex = -1) -> list[str]: ...  # type: ignore[misc]
-    @overload
-    def rstrip(self: LiteralString, __chars: LiteralString | None = None) -> LiteralString: ...
-    @overload
     def rstrip(self, __chars: str | None = None) -> str: ...  # type: ignore[misc]
-    @overload
-    def split(self: LiteralString, sep: LiteralString | None = None, maxsplit: SupportsIndex = -1) -> list[LiteralString]: ...
-    @overload
     def split(self, sep: str | None = None, maxsplit: SupportsIndex = -1) -> list[str]: ...  # type: ignore[misc]
-    @overload
-    def splitlines(self: LiteralString, keepends: bool = False) -> list[LiteralString]: ...
-    @overload
     def splitlines(self, keepends: bool = False) -> list[str]: ...  # type: ignore[misc]
     def startswith(
         self, __prefix: str | tuple[str, ...], __start: SupportsIndex | None = ..., __end: SupportsIndex | None = ...
     ) -> bool: ...
-    @overload
-    def strip(self: LiteralString, __chars: LiteralString | None = None) -> LiteralString: ...
-    @overload
     def strip(self, __chars: str | None = None) -> str: ...  # type: ignore[misc]
-    @overload
-    def swapcase(self: LiteralString) -> LiteralString: ...
-    @overload
     def swapcase(self) -> str: ...  # type: ignore[misc]
-    @overload
-    def title(self: LiteralString) -> LiteralString: ...
-    @overload
     def title(self) -> str: ...  # type: ignore[misc]
     def translate(self, __table: _TranslateTable) -> str: ...
-    @overload
-    def upper(self: LiteralString) -> LiteralString: ...
-    @overload
     def upper(self) -> str: ...  # type: ignore[misc]
-    @overload
-    def zfill(self: LiteralString, __width: SupportsIndex) -> LiteralString: ...
-    @overload
     def zfill(self, __width: SupportsIndex) -> str: ...  # type: ignore[misc]
     @staticmethod
     @overload
@@ -575,9 +497,6 @@ class str(Sequence[str]):
     @staticmethod
     @overload
     def maketrans(__x: str, __y: str, __z: str) -> dict[int, int | None]: ...
-    @overload
-    def __add__(self: LiteralString, __value: LiteralString) -> LiteralString: ...
-    @overload
     def __add__(self, __value: str) -> str: ...  # type: ignore[misc]
     # Incompatible with Sequence.__contains__
     def __contains__(self, __key: str) -> bool: ...  # type: ignore[override]
@@ -585,25 +504,13 @@ class str(Sequence[str]):
     def __ge__(self, __value: str) -> bool: ...
     def __getitem__(self, __key: SupportsIndex | slice) -> str: ...
     def __gt__(self, __value: str) -> bool: ...
-    @overload
-    def __iter__(self: LiteralString) -> Iterator[LiteralString]: ...
-    @overload
     def __iter__(self) -> Iterator[str]: ...  # type: ignore[misc]
     def __le__(self, __value: str) -> bool: ...
     def __len__(self) -> int: ...
     def __lt__(self, __value: str) -> bool: ...
-    @overload
-    def __mod__(self: LiteralString, __value: LiteralString | tuple[LiteralString, ...]) -> LiteralString: ...
-    @overload
     def __mod__(self, __value: Any) -> str: ...
-    @overload
-    def __mul__(self: LiteralString, __value: SupportsIndex) -> LiteralString: ...
-    @overload
     def __mul__(self, __value: SupportsIndex) -> str: ...  # type: ignore[misc]
     def __ne__(self, __value: object) -> bool: ...
-    @overload
-    def __rmul__(self: LiteralString, __value: SupportsIndex) -> LiteralString: ...
-    @overload
     def __rmul__(self, __value: SupportsIndex) -> str: ...  # type: ignore[misc]
     def __getnewargs__(self) -> tuple[str]: ...
 

From 56f43433673fe97de14b903cbeb9bc940b67f09d Mon Sep 17 00:00:00 2001
From: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
Date: Sat, 29 Oct 2022 12:47:21 -0700
Subject: [PATCH 110/129] Revert sum literal integer change (#13961)

This is allegedly causing large performance problems, see 13821

typeshed/8231 had zero hits on mypy_primer, so it's not the worst thing
to undo. Patching this in typeshed also feels weird, since there's a
more general soundness issue. If a typevar has a bound or constraint, we
might not want to solve it to a Literal.

If we can confirm the performance regression or fix the unsoundness
within mypy, I might pursue upstreaming this in typeshed.

(Reminder: add this to the sync_typeshed script once merged)
---
 mypy/typeshed/stdlib/builtins.pyi | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/mypy/typeshed/stdlib/builtins.pyi b/mypy/typeshed/stdlib/builtins.pyi
index 58669c9b45002..7415a1b7680d5 100644
--- a/mypy/typeshed/stdlib/builtins.pyi
+++ b/mypy/typeshed/stdlib/builtins.pyi
@@ -1665,11 +1665,11 @@ _SupportsSumNoDefaultT = TypeVar("_SupportsSumNoDefaultT", bound=_SupportsSumWit
 # Instead, we special-case the most common examples of this: bool and literal integers.
 if sys.version_info >= (3, 8):
     @overload
-    def sum(__iterable: Iterable[bool | _LiteralInteger], start: int = 0) -> int: ...  # type: ignore[misc]
+    def sum(__iterable: Iterable[bool], start: int = 0) -> int: ...  # type: ignore[misc]
 
 else:
     @overload
-    def sum(__iterable: Iterable[bool | _LiteralInteger], __start: int = 0) -> int: ...  # type: ignore[misc]
+    def sum(__iterable: Iterable[bool], __start: int = 0) -> int: ...  # type: ignore[misc]
 
 @overload
 def sum(__iterable: Iterable[_SupportsSumNoDefaultT]) -> _SupportsSumNoDefaultT | Literal[0]: ...

From 71c4269df306e53cb0eec7474dcde26e5a72d45e Mon Sep 17 00:00:00 2001
From: AlexWaygood <alex.waygood@gmail.com>
Date: Mon, 1 May 2023 20:34:55 +0100
Subject: [PATCH 111/129] Revert typeshed ctypes change Since the plugin
 provides superior type checking:
 https://github.com/python/mypy/pull/13987#issuecomment-1310863427 A manual
 cherry-pick of e437cdf.

---
 mypy/typeshed/stdlib/_ctypes.pyi | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/mypy/typeshed/stdlib/_ctypes.pyi b/mypy/typeshed/stdlib/_ctypes.pyi
index 25d604218a00d..756ee86d33429 100644
--- a/mypy/typeshed/stdlib/_ctypes.pyi
+++ b/mypy/typeshed/stdlib/_ctypes.pyi
@@ -151,11 +151,7 @@ class Array(Generic[_CT], _CData):
     def _type_(self) -> type[_CT]: ...
     @_type_.setter
     def _type_(self, value: type[_CT]) -> None: ...
-    # Note: only available if _CT == c_char
-    @property
-    def raw(self) -> bytes: ...
-    @raw.setter
-    def raw(self, value: ReadableBuffer) -> None: ...
+    raw: bytes  # Note: only available if _CT == c_char
     value: Any  # Note: bytes if _CT == c_char, str if _CT == c_wchar, unavailable otherwise
     # TODO These methods cannot be annotated correctly at the moment.
     # All of these "Any"s stand for the array's element type, but it's not possible to use _CT

From 186fbb18e1cb30c8e51b79fe2d193c15a49d4588 Mon Sep 17 00:00:00 2001
From: AlexWaygood <alex.waygood@gmail.com>
Date: Sat, 4 Mar 2023 13:14:11 +0000
Subject: [PATCH 112/129] Revert use of `ParamSpec` for `functools.wraps`

---
 mypy/typeshed/stdlib/functools.pyi | 40 +++++++++++-------------------
 1 file changed, 14 insertions(+), 26 deletions(-)

diff --git a/mypy/typeshed/stdlib/functools.pyi b/mypy/typeshed/stdlib/functools.pyi
index 8adc3d82292e2..1b4e59b7c1204 100644
--- a/mypy/typeshed/stdlib/functools.pyi
+++ b/mypy/typeshed/stdlib/functools.pyi
@@ -1,9 +1,9 @@
 import sys
 import types
-from _typeshed import SupportsAllComparisons, SupportsItems
+from _typeshed import IdentityFunction, SupportsAllComparisons, SupportsItems
 from collections.abc import Callable, Hashable, Iterable, Sequence, Sized
 from typing import Any, Generic, NamedTuple, TypeVar, overload
-from typing_extensions import Literal, ParamSpec, Self, TypeAlias, TypedDict, final
+from typing_extensions import Literal, Self, TypeAlias, TypedDict, final
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -28,12 +28,10 @@ if sys.version_info >= (3, 8):
 if sys.version_info >= (3, 9):
     __all__ += ["cache"]
 
+_AnyCallable: TypeAlias = Callable[..., object]
+
 _T = TypeVar("_T")
 _S = TypeVar("_S")
-_PWrapped = ParamSpec("_PWrapped")
-_RWrapped = TypeVar("_RWrapped")
-_PWrapper = ParamSpec("_PWrapper")
-_RWapper = TypeVar("_RWapper")
 
 @overload
 def reduce(function: Callable[[_T, _S], _T], sequence: Iterable[_S], initial: _T) -> _T: ...
@@ -87,41 +85,31 @@ else:
     ]
 WRAPPER_UPDATES: tuple[Literal["__dict__"]]
 
-class _Wrapped(Generic[_PWrapped, _RWrapped, _PWrapper, _RWapper]):
-    __wrapped__: Callable[_PWrapped, _RWrapped]
-    def __call__(self, *args: _PWrapper.args, **kwargs: _PWrapper.kwargs) -> _RWapper: ...
-    # as with ``Callable``, we'll assume that these attributes exist
-    __name__: str
-    __qualname__: str
-
-class _Wrapper(Generic[_PWrapped, _RWrapped]):
-    def __call__(self, f: Callable[_PWrapper, _RWapper]) -> _Wrapped[_PWrapped, _RWrapped, _PWrapper, _RWapper]: ...
-
 if sys.version_info >= (3, 12):
     def update_wrapper(
-        wrapper: Callable[_PWrapper, _RWapper],
-        wrapped: Callable[_PWrapped, _RWrapped],
+        wrapper: _T,
+        wrapped: _AnyCallable,
         assigned: Sequence[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__", "__type_params__"),
         updated: Sequence[str] = ("__dict__",),
-    ) -> _Wrapped[_PWrapped, _RWrapped, _PWrapper, _RWapper]: ...
+    ) -> _T: ...
     def wraps(
-        wrapped: Callable[_PWrapped, _RWrapped],
+        wrapped: _AnyCallable,
         assigned: Sequence[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__", "__type_params__"),
         updated: Sequence[str] = ("__dict__",),
-    ) -> _Wrapper[_PWrapped, _RWrapped]: ...
+    ) -> IdentityFunction: ...
 
 else:
     def update_wrapper(
-        wrapper: Callable[_PWrapper, _RWapper],
-        wrapped: Callable[_PWrapped, _RWrapped],
+        wrapper: _T,
+        wrapped: _AnyCallable,
         assigned: Sequence[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__"),
         updated: Sequence[str] = ("__dict__",),
-    ) -> _Wrapped[_PWrapped, _RWrapped, _PWrapper, _RWapper]: ...
+    ) -> _T: ...
     def wraps(
-        wrapped: Callable[_PWrapped, _RWrapped],
+        wrapped: _AnyCallable,
         assigned: Sequence[str] = ("__module__", "__name__", "__qualname__", "__doc__", "__annotations__"),
         updated: Sequence[str] = ("__dict__",),
-    ) -> _Wrapper[_PWrapped, _RWrapped]: ...
+    ) -> IdentityFunction: ...
 
 def total_ordering(cls: type[_T]) -> type[_T]: ...
 def cmp_to_key(mycmp: Callable[[_T, _T], int]) -> Callable[[_T], SupportsAllComparisons]: ...

From a9f8df7cda032f637946bb2ea7a60f790f81350f Mon Sep 17 00:00:00 2001
From: Alex Waygood <Alex.Waygood@Gmail.com>
Date: Tue, 4 Jul 2023 20:04:46 +0100
Subject: [PATCH 113/129] Remove `six` as a test dependency (#15589)

---
 mypyc/test-data/run-classes.test | 17 +++--------------
 test-requirements.txt            |  3 +--
 2 files changed, 4 insertions(+), 16 deletions(-)

diff --git a/mypyc/test-data/run-classes.test b/mypyc/test-data/run-classes.test
index 268e07f6bde4c..59617714f7e73 100644
--- a/mypyc/test-data/run-classes.test
+++ b/mypyc/test-data/run-classes.test
@@ -1370,9 +1370,8 @@ except TypeError as e:
 
 [case testMetaclass]
 from meta import Meta
-import six
 
-class Nothing1(metaclass=Meta):
+class Nothing(metaclass=Meta):
     pass
 
 def ident(x): return x
@@ -1381,15 +1380,7 @@ def ident(x): return x
 class Test:
     pass
 
-class Nothing2(six.with_metaclass(Meta, Test)):
-    pass
-
-@six.add_metaclass(Meta)
-class Nothing3:
-    pass
-
 [file meta.py]
-from typing import Any
 class Meta(type):
     def __new__(mcs, name, bases, dct):
         dct['X'] = 10
@@ -1397,10 +1388,8 @@ class Meta(type):
 
 
 [file driver.py]
-from native import Nothing1, Nothing2, Nothing3
-assert Nothing1.X == 10
-assert Nothing2.X == 10
-assert Nothing3.X == 10
+from native import Nothing
+assert Nothing.X == 10
 
 [case testPickling]
 from mypy_extensions import trait, mypyc_attr
diff --git a/test-requirements.txt b/test-requirements.txt
index 6b046e1469ebe..6611878233689 100644
--- a/test-requirements.txt
+++ b/test-requirements.txt
@@ -14,5 +14,4 @@ pytest-xdist>=1.34.0
 pytest-cov>=2.10.0
 ruff==0.0.272  # must match version in .pre-commit-config.yaml
 setuptools>=65.5.1
-six
-tomli>=1.1.0
+tomli>=1.1.0  # needed even on py311+ so the self check passes with --python-version 3.7

From 1e14d13a4453a0a68909650faba86f683a1b90a5 Mon Sep 17 00:00:00 2001
From: Valentin Stanciu <250871+svalentin@users.noreply.github.com>
Date: Tue, 4 Jul 2023 20:15:43 +0100
Subject: [PATCH 114/129] Update commits for sync-typeshed cherry picks
 (#15592)

Got commits from https://github.com/python/mypy/commits/master after
merging https://github.com/python/mypy/pull/15590
---
 misc/sync-typeshed.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/misc/sync-typeshed.py b/misc/sync-typeshed.py
index cbaa7029620f4..3f870d574d38f 100644
--- a/misc/sync-typeshed.py
+++ b/misc/sync-typeshed.py
@@ -179,10 +179,10 @@ def main() -> None:
     print("Created typeshed sync commit.")
 
     commits_to_cherry_pick = [
-        "6f913a148",  # LiteralString reverts
-        "475a46a78",  # sum reverts
-        "f5e5c117d",  # ctypes reverts
-        "9f3bbbeb1",  # ParamSpec for functools.wraps
+        "9f4c0d8af",  # LiteralString reverts
+        "56f434336",  # sum reverts
+        "71c4269df",  # ctypes reverts
+        "186fbb18e",  # ParamSpec for functools.wraps
     ]
     for commit in commits_to_cherry_pick:
         try:

From 7d1a89998e90acd36a5673399f5e75bc029526f9 Mon Sep 17 00:00:00 2001
From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
Date: Tue, 4 Jul 2023 23:48:17 +0200
Subject: [PATCH 115/129] Add foundation to enable `--strict-optional` in all
 test files (#15586)

---
 mypy/test/helpers.py         | 11 ++++++---
 mypy/test/testcheck.py       | 46 +++++++++++++++++++++++++++++++++++-
 mypy/test/testfinegrained.py |  7 +++++-
 3 files changed, 59 insertions(+), 5 deletions(-)

diff --git a/mypy/test/helpers.py b/mypy/test/helpers.py
index 630ba305f349f..1e034f94dd927 100644
--- a/mypy/test/helpers.py
+++ b/mypy/test/helpers.py
@@ -7,7 +7,7 @@
 import shutil
 import sys
 import time
-from typing import Any, Callable, Iterable, Iterator, Pattern
+from typing import Any, Callable, Collection, Iterable, Iterator, Pattern
 
 # Exporting Suite as alias to TestCase for backwards compatibility
 # TODO: avoid aliasing - import and subclass TestCase directly
@@ -317,7 +317,10 @@ def assert_type(typ: type, value: object) -> None:
 
 
 def parse_options(
-    program_text: str, testcase: DataDrivenTestCase, incremental_step: int
+    program_text: str,
+    testcase: DataDrivenTestCase,
+    incremental_step: int,
+    no_strict_optional_files: Collection[str] = (),
 ) -> Options:
     """Parse comments like '# flags: --foo' in a test case."""
     options = Options()
@@ -340,7 +343,9 @@ def parse_options(
         flag_list = []
         options = Options()
         # TODO: Enable strict optional in test cases by default (requires *many* test case changes)
-        options.strict_optional = False
+        if os.path.basename(testcase.file) in no_strict_optional_files:
+            options.strict_optional = False
+
         options.error_summary = False
         options.hide_error_codes = True
         options.force_uppercase_builtins = True
diff --git a/mypy/test/testcheck.py b/mypy/test/testcheck.py
index 20dfbb77f3e04..6c7007764f581 100644
--- a/mypy/test/testcheck.py
+++ b/mypy/test/testcheck.py
@@ -49,6 +49,48 @@
     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-abstract.test",
+    "check-async-await.test",
+    "check-basic.test",
+    "check-bound.test",
+    "check-classes.test",
+    "check-dynamic-typing.test",
+    "check-enum.test",
+    "check-expressions.test",
+    "check-formatting.test",
+    "check-functions.test",
+    "check-generic-subtyping.test",
+    "check-generics.test",
+    "check-incremental.test",
+    "check-inference-context.test",
+    "check-inference.test",
+    "check-inline-config.test",
+    "check-isinstance.test",
+    "check-kwargs.test",
+    "check-lists.test",
+    "check-literal.test",
+    "check-modules.test",
+    "check-namedtuple.test",
+    "check-newsemanal.test",
+    "check-overloading.test",
+    "check-plugin-attrs.test",
+    "check-protocols.test",
+    "check-selftype.test",
+    "check-serialize.test",
+    "check-statements.test",
+    "check-super.test",
+    "check-tuples.test",
+    "check-type-aliases.test",
+    "check-type-checks.test",
+    "check-typeddict.test",
+    "check-typevar-values.test",
+    "check-unions.test",
+    "check-varargs.test",
+}
+
+
 class TypeCheckSuite(DataSuite):
     files = typecheck_files
 
@@ -121,7 +163,9 @@ 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)
+        options = parse_options(
+            original_program_text, testcase, incremental_step, no_strict_optional_files
+        )
         options.use_builtins_fixtures = True
         if not testcase.name.endswith("_no_incomplete"):
             options.enable_incomplete_feature = [TYPE_VAR_TUPLE, UNPACK]
diff --git a/mypy/test/testfinegrained.py b/mypy/test/testfinegrained.py
index ba0526d325588..a1dde823cb5f2 100644
--- a/mypy/test/testfinegrained.py
+++ b/mypy/test/testfinegrained.py
@@ -45,6 +45,9 @@
 # Set to True to perform (somewhat expensive) checks for duplicate AST nodes after merge
 CHECK_CONSISTENCY = False
 
+# TODO: Enable strict optional in test cases by default. Remove files here, once test cases are updated
+no_strict_optional_files = {"fine-grained.test", "fine-grained-suggest.test"}
+
 
 class FineGrainedSuite(DataSuite):
     files = find_test_files(
@@ -140,7 +143,9 @@ def run_case(self, testcase: DataDrivenTestCase) -> None:
 
     def get_options(self, source: str, testcase: DataDrivenTestCase, build_cache: bool) -> Options:
         # This handles things like '# flags: --foo'.
-        options = parse_options(source, testcase, incremental_step=1)
+        options = parse_options(
+            source, testcase, incremental_step=1, no_strict_optional_files=no_strict_optional_files
+        )
         options.incremental = True
         options.use_builtins_fixtures = True
         options.show_traceback = True

From c13f1d416e907f58bc77d086b84819f500f1bde9 Mon Sep 17 00:00:00 2001
From: Erik Kemperman <erikkemperman@gmail.com>
Date: Wed, 5 Jul 2023 09:34:11 +0200
Subject: [PATCH 116/129] Better consistency with explicit staticmethods
 (#15353)

---
 mypy/checker.py                    |  5 ++-
 mypy/checkmember.py                |  6 +---
 mypy/nodes.py                      |  2 +-
 mypy/semanal.py                    |  8 +++--
 mypy/typeops.py                    |  2 +-
 test-data/unit/check-selftype.test | 52 ++++++++++++++++++++++++++++++
 6 files changed, 62 insertions(+), 13 deletions(-)

diff --git a/mypy/checker.py b/mypy/checker.py
index bf200299d8b33..5ed1c792778b4 100644
--- a/mypy/checker.py
+++ b/mypy/checker.py
@@ -1164,11 +1164,10 @@ def check_func_def(
                         isinstance(defn, FuncDef)
                         and ref_type is not None
                         and i == 0
-                        and not defn.is_static
+                        and (not defn.is_static or defn.name == "__new__")
                         and typ.arg_kinds[0] not in [nodes.ARG_STAR, nodes.ARG_STAR2]
                     ):
-                        isclass = defn.is_class or defn.name in ("__new__", "__init_subclass__")
-                        if isclass:
+                        if defn.is_class or defn.name == "__new__":
                             ref_type = mypy.types.TypeType.make_normalized(ref_type)
                         erased = get_proper_type(erase_to_bound(arg_type))
                         if not is_subtype(ref_type, erased, ignore_type_params=True):
diff --git a/mypy/checkmember.py b/mypy/checkmember.py
index 36fea9daa3e38..343dfe3de2431 100644
--- a/mypy/checkmember.py
+++ b/mypy/checkmember.py
@@ -319,11 +319,7 @@ def analyze_instance_member_access(
             mx.msg.cant_assign_to_method(mx.context)
         signature = function_type(method, mx.named_type("builtins.function"))
         signature = freshen_all_functions_type_vars(signature)
-        if name == "__new__" or method.is_static:
-            # __new__ is special and behaves like a static method -- don't strip
-            # the first argument.
-            pass
-        else:
+        if not method.is_static:
             if name != "__call__":
                 # TODO: use proper treatment of special methods on unions instead
                 #       of this hack here and below (i.e. mx.self_type).
diff --git a/mypy/nodes.py b/mypy/nodes.py
index eb093f5d45b06..2d763fc482d3e 100644
--- a/mypy/nodes.py
+++ b/mypy/nodes.py
@@ -512,7 +512,7 @@ class FuncBase(Node):
         "info",
         "is_property",
         "is_class",  # Uses "@classmethod" (explicit or implicit)
-        "is_static",  # Uses "@staticmethod"
+        "is_static",  # Uses "@staticmethod" (explicit or implicit)
         "is_final",  # Uses "@final"
         "is_explicit_override",  # Uses "@override"
         "_fullname",
diff --git a/mypy/semanal.py b/mypy/semanal.py
index 1f15691ae205b..f4f281e7a77ab 100644
--- a/mypy/semanal.py
+++ b/mypy/semanal.py
@@ -959,9 +959,11 @@ def remove_unpack_kwargs(self, defn: FuncDef, typ: CallableType) -> CallableType
 
     def prepare_method_signature(self, func: FuncDef, info: TypeInfo, has_self_type: bool) -> None:
         """Check basic signature validity and tweak annotation of self/cls argument."""
-        # Only non-static methods are special.
+        # Only non-static methods are special, as well as __new__.
         functype = func.type
-        if not func.is_static:
+        if func.name == "__new__":
+            func.is_static = True
+        if not func.is_static or func.name == "__new__":
             if func.name in ["__init_subclass__", "__class_getitem__"]:
                 func.is_class = True
             if not func.arguments:
@@ -1397,7 +1399,7 @@ def analyze_function_body(self, defn: FuncItem) -> None:
                 # The first argument of a non-static, non-class method is like 'self'
                 # (though the name could be different), having the enclosing class's
                 # instance type.
-                if is_method and not defn.is_static and defn.arguments:
+                if is_method and (not defn.is_static or defn.name == "__new__") and defn.arguments:
                     if not defn.is_class:
                         defn.arguments[0].variable.is_self = True
                     else:
diff --git a/mypy/typeops.py b/mypy/typeops.py
index 58a641a54ab70..519d3de995f57 100644
--- a/mypy/typeops.py
+++ b/mypy/typeops.py
@@ -710,7 +710,7 @@ def callable_type(
     fdef: FuncItem, fallback: Instance, ret_type: Type | None = None
 ) -> CallableType:
     # TODO: somewhat unfortunate duplication with prepare_method_signature in semanal
-    if fdef.info and not fdef.is_static and fdef.arg_names:
+    if fdef.info and (not fdef.is_static or fdef.name == "__new__") and fdef.arg_names:
         self_type: Type = fill_typevars(fdef.info)
         if fdef.is_class or fdef.name == "__new__":
             self_type = TypeType.make_normalized(self_type)
diff --git a/test-data/unit/check-selftype.test b/test-data/unit/check-selftype.test
index 4155e33438516..dc7a6c239fe61 100644
--- a/test-data/unit/check-selftype.test
+++ b/test-data/unit/check-selftype.test
@@ -509,6 +509,58 @@ class E:
     def __init_subclass__(cls) -> None:
         reveal_type(cls)  # N: Revealed type is "Type[__main__.E]"
 
+[case testSelfTypeNew_explicit]
+from typing import TypeVar, Type
+
+T = TypeVar('T', bound='A')
+class A:
+    @staticmethod
+    def __new__(cls: Type[T]) -> T:
+        return cls()
+
+    @classmethod
+    def __init_subclass__(cls: Type[T]) -> None:
+        pass
+
+class B:
+    @staticmethod
+    def __new__(cls: Type[T]) -> T:  # E: The erased type of self "Type[__main__.A]" is not a supertype of its class "Type[__main__.B]"
+        return cls()
+
+    @classmethod
+    def __init_subclass__(cls: Type[T]) -> None:  # E: The erased type of self "Type[__main__.A]" is not a supertype of its class "Type[__main__.B]"
+        pass
+
+class C:
+    @staticmethod
+    def __new__(cls: Type[C]) -> C:
+        return cls()
+
+    @classmethod
+    def __init_subclass__(cls: Type[C]) -> None:
+        pass
+
+class D:
+    @staticmethod
+    def __new__(cls: D) -> D:  # E: The erased type of self "__main__.D" is not a supertype of its class "Type[__main__.D]"
+        return cls
+
+    @classmethod
+    def __init_subclass__(cls: D) -> None:  # E: The erased type of self "__main__.D" is not a supertype of its class "Type[__main__.D]"
+        pass
+
+class E:
+    @staticmethod
+    def __new__(cls) -> E:
+        reveal_type(cls)  # N: Revealed type is "Type[__main__.E]"
+        return cls()
+
+    @classmethod
+    def __init_subclass__(cls) -> None:
+        reveal_type(cls)  # N: Revealed type is "Type[__main__.E]"
+
+[builtins fixtures/classmethod.pyi]
+
 [case testSelfTypePropertyUnion]
 from typing import Union
 class A:

From 8f66718d996c11fc1f86c21331b31dcc57763cf0 Mon Sep 17 00:00:00 2001
From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
Date: Wed, 5 Jul 2023 20:55:45 +0200
Subject: [PATCH 117/129] Enable strict optional for more test files (1)
 (#15595)

---
 mypy/test/testcheck.py                |  4 --
 test-data/unit/check-abstract.test    | 47 ++++++++------
 test-data/unit/check-async-await.test |  4 +-
 test-data/unit/check-classes.test     | 92 +++++++++++++++------------
 test-data/unit/check-enum.test        |  4 +-
 5 files changed, 82 insertions(+), 69 deletions(-)

diff --git a/mypy/test/testcheck.py b/mypy/test/testcheck.py
index 6c7007764f581..c9e66e4270b63 100644
--- a/mypy/test/testcheck.py
+++ b/mypy/test/testcheck.py
@@ -51,13 +51,9 @@
 
 # TODO: Enable strict optional in test cases by default. Remove files here, once test cases are updated
 no_strict_optional_files = {
-    "check-abstract.test",
-    "check-async-await.test",
     "check-basic.test",
     "check-bound.test",
-    "check-classes.test",
     "check-dynamic-typing.test",
-    "check-enum.test",
     "check-expressions.test",
     "check-formatting.test",
     "check-functions.test",
diff --git a/test-data/unit/check-abstract.test b/test-data/unit/check-abstract.test
index 3a0a30a14462f..1c85fae93dd40 100644
--- a/test-data/unit/check-abstract.test
+++ b/test-data/unit/check-abstract.test
@@ -9,11 +9,11 @@
 
 from abc import abstractmethod, ABCMeta
 
-i = None # type: I
-j = None # type: J
-a = None # type: A
-b = None # type: B
-c = None # type: C
+i: I
+j: J
+a: A
+b: B
+c: C
 
 def f(): i, j, a, b, c # Prevent redefinition
 
@@ -44,10 +44,10 @@ class C(I): pass
 
 from abc import abstractmethod, ABCMeta
 
-i = None # type: I
-j = None # type: J
-a = None # type: A
-o = None # type: object
+i: I
+j: J
+a: A
+o: object
 
 def f(): i, j, a, o # Prevent redefinition
 
@@ -73,9 +73,9 @@ class A(J): pass
 [case testInheritingAbstractClassInSubclass]
 from abc import abstractmethod, ABCMeta
 
-i = None # type: I
-a = None # type: A
-b = None # type: B
+i: I
+a: A
+b: B
 
 if int():
     i = a # E: Incompatible types in assignment (expression has type "A", variable has type "I")
@@ -106,8 +106,8 @@ class I(metaclass=ABCMeta):
   @abstractmethod
   def f(self): pass
 
-o = None # type: object
-t = None # type: type
+o: object
+t: type
 
 o = I
 t = I
@@ -122,8 +122,10 @@ class I(metaclass=ABCMeta):
 class A(I): pass
 class B: pass
 
-i, a, b = None, None, None # type: (I, A, B)
-o = None # type: object
+i: I
+a: A
+b: B
+o: object
 
 if int():
     a = cast(I, o) # E: Incompatible types in assignment (expression has type "I", variable has type "A")
@@ -220,6 +222,7 @@ f(GoodAlias)
 [out]
 
 [case testInstantiationAbstractsInTypeForVariables]
+# flags: --no-strict-optional
 from typing import Type
 from abc import abstractmethod
 
@@ -399,7 +402,9 @@ class I(metaclass=ABCMeta):
     @abstractmethod
     def f(self, a: int) -> str: pass
 
-i, a, b = None, None, None # type: (I, int, str)
+i: I
+a: int
+b: str
 
 if int():
     a = i.f(a) # E: Incompatible types in assignment (expression has type "str", variable has type "int")
@@ -419,7 +424,9 @@ class J(metaclass=ABCMeta):
     def f(self, a: int) -> str: pass
 class I(J): pass
 
-i, a, b = None, None, None # type: (I, int, str)
+i: I
+a: int
+b: str
 
 if int():
     a = i.f(1) # E: Incompatible types in assignment (expression has type "str", variable has type "int")
@@ -505,7 +512,7 @@ class B(metaclass=ABCMeta):
     @abstractmethod
     def g(self) -> None: pass
 class C(A, B): pass
-x = None # type: C
+x: C
 x.f()
 x.g()
 x.f(x) # E: Too many arguments for "f" of "A"
@@ -737,6 +744,7 @@ class A(metaclass=ABCMeta):
     def x(self, x: int) -> None: pass
 
 [case testReadWriteDeleteAbstractProperty]
+# flags: --no-strict-optional
 from abc import ABC, abstractmethod
 class Abstract(ABC):
     @property
@@ -853,6 +861,7 @@ main:8: error: Cannot instantiate abstract class "B" with abstract attribute "x"
 main:9: error: "int" has no attribute "y"
 
 [case testSuperWithAbstractProperty]
+# flags: --no-strict-optional
 from abc import abstractproperty, ABCMeta
 class A(metaclass=ABCMeta):
     @abstractproperty
diff --git a/test-data/unit/check-async-await.test b/test-data/unit/check-async-await.test
index d0df2c9e01042..bcf55d84ff26f 100644
--- a/test-data/unit/check-async-await.test
+++ b/test-data/unit/check-async-await.test
@@ -291,7 +291,7 @@ async def f() -> None:
 [typing fixtures/typing-async.pyi]
 
 [case testAsyncWithErrorBadAenter2]
-
+# flags: --no-strict-optional
 class C:
     def __aenter__(self) -> None: pass
     async def __aexit__(self, x, y, z) -> None: pass
@@ -313,7 +313,7 @@ async def f() -> None:
 [typing fixtures/typing-async.pyi]
 
 [case testAsyncWithErrorBadAexit2]
-
+# flags: --no-strict-optional
 class C:
     async def __aenter__(self) -> int: pass
     def __aexit__(self, x, y, z) -> None: pass
diff --git a/test-data/unit/check-classes.test b/test-data/unit/check-classes.test
index 2c80eb7b49bc6..69227e50f6fae 100644
--- a/test-data/unit/check-classes.test
+++ b/test-data/unit/check-classes.test
@@ -8,8 +8,8 @@ class A:
 class B:
     def bar(self, x: 'B', y: A) -> None: pass
 
-a = None # type: A
-b = None # type: B
+a: A
+b: B
 
 a.foo(B())  # E: Argument 1 to "foo" of "A" has incompatible type "B"; expected "A"
 a.bar(B(), A())  # E: "A" has no attribute "bar"
@@ -23,7 +23,7 @@ class A:
     def bar(self, x: 'B') -> None: pass
 class B(A): pass
 
-a = None # type: A
+a: A
 a.foo(A())
 a.foo(B())
 a.bar(A()) # E: Argument 1 to "bar" of "A" has incompatible type "A"; expected "B"
@@ -34,7 +34,7 @@ class A:
     def foo(self, x: 'B') -> None: pass
 class B(A): pass
 
-a = None # type: B
+a: B
 a.foo(A()) # Fail
 a.foo(B())
 
@@ -46,7 +46,7 @@ main:6: error: Argument 1 to "foo" of "A" has incompatible type "A"; expected "B
 class A:
     def foo(self, x: 'A') -> None: pass
 
-a = None # type: A
+a: A
 a.foo()               # Fail
 a.foo(object(), A())  # Fail
 [out]
@@ -103,7 +103,8 @@ main:5: error: "A" has no attribute "g"
 import typing
 class A:
     def f(self): pass
-A().f = None # E: Cannot assign to a method
+A().f = None  # E: Cannot assign to a method \
+              # E: Incompatible types in assignment (expression has type "None", variable has type "Callable[[], Any]")
 
 
 [case testOverrideAttributeWithMethod]
@@ -202,8 +203,8 @@ class A:
         self.a = aa
         self.b = bb
 class B: pass
-a = None # type: A
-b = None # type: B
+a: A
+b: B
 a.a = b # Fail
 a.b = a # Fail
 b.a     # Fail
@@ -217,8 +218,8 @@ main:11: error: "B" has no attribute "a"
 [case testExplicitAttributeInBody]
 
 class A:
-  x = None # type: A
-a = None # type: A
+  x: A
+a: A
 a.x = object() # E: Incompatible types in assignment (expression has type "object", variable has type "A")
 a.x = A()
 
@@ -458,9 +459,10 @@ class A:
     def g(self) -> 'A': pass
 class B(A):
     def f(self) -> A: pass  # Fail
-    def g(self) -> None: pass
+    def g(self) -> None: pass  # Fail
 [out]
 main:6: error: Return type "A" of "f" incompatible with return type "None" in supertype "A"
+main:7: error: Return type "None" of "g" incompatible with return type "A" in supertype "A"
 
 [case testOverride__new__WithDifferentSignature]
 class A:
@@ -907,7 +909,7 @@ b = __init__() # type: B # E: Incompatible types in assignment (expression has t
 from typing import Any, cast
 class A:
     def __init__(self, a: 'A') -> None: pass
-a = None # type: A
+a: A
 a.__init__(a)  # E: Accessing "__init__" on an instance is unsound, since instance.__init__ could be from an incompatible subclass
 (cast(Any, a)).__init__(a)
 
@@ -1017,13 +1019,14 @@ class A:
 A.f(A())
 A.f(object())     # E: Argument 1 to "f" of "A" has incompatible type "object"; expected "A"
 A.f()             # E: Missing positional argument "self" in call to "f" of "A"
-A.f(None, None)   # E: Too many arguments for "f" of "A"
+A.f(None, None)   # E: Too many arguments for "f" of "A" \
+                  # E: Argument 1 to "f" of "A" has incompatible type "None"; expected "A"
 
 [case testAccessAttributeViaClass]
 import typing
 class B: pass
 class A:
-    x = None # type: A
+    x: A
 a = A.x # type: A
 b = A.x # type: B # E: Incompatible types in assignment (expression has type "A", variable has type "B")
 
@@ -1060,7 +1063,7 @@ A.f()    # E: Missing positional argument "self" in call to "f" of "A"
 import typing
 class B: pass
 class A:
-    x = None # type: B
+    x: B
 A.x = B()
 A.x = object()  # E: Incompatible types in assignment (expression has type "object", variable has type "B")
 
@@ -1077,8 +1080,8 @@ A.x = A()   # E: Incompatible types in assignment (expression has type "A", vari
 class B: pass
 class A:
     def __init__(self, b: B) -> None: pass
-a = None # type: A
-b = None # type: B
+a: A
+b: B
 A.__init__(a, b)
 A.__init__(b, b) # E: Argument 1 to "__init__" of "A" has incompatible type "B"; expected "A"
 A.__init__(a, a) # E: Argument 2 to "__init__" of "A" has incompatible type "A"; expected "B"
@@ -1087,13 +1090,15 @@ A.__init__(a, a) # E: Argument 2 to "__init__" of "A" has incompatible type "A";
 import typing
 class A:
     def f(self): pass
-A.f = None # E: Cannot assign to a method
+A.f = None  # E: Cannot assign to a method \
+            # E: Incompatible types in assignment (expression has type "None", variable has type "Callable[[A], Any]")
 
 [case testAssignToNestedClassViaClass]
 import typing
 class A:
     class B: pass
-A.B = None # E: Cannot assign to a type
+A.B = None  # E: Cannot assign to a type \
+            # E: Incompatible types in assignment (expression has type "None", variable has type "Type[B]")
 [targets __main__]
 
 [case testAccessingClassAttributeWithTypeInferenceIssue]
@@ -1139,7 +1144,7 @@ A[int, int].x  # E: Access to generic instance variables via class is ambiguous
 def f() -> None:
     class A:
         def g(self) -> None: pass
-    a = None # type: A
+    a: A
     a.g()
     a.g(a) # E: Too many arguments for "g" of "A"
 [targets __main__, __main__.f]
@@ -1200,7 +1205,7 @@ class A:
 
 def f() -> None:
     class A: pass
-    a = None # type: A
+    a: A
     if int():
         a = A()
         a = object() # E: Incompatible types in assignment (expression has type "object", variable has type "A")
@@ -1209,7 +1214,7 @@ def f() -> None:
 [case testExternalReferenceToClassWithinClass]
 class A:
     class B: pass
-b = None # type: A.B
+b: A.B
 if int():
     b = A.B()
 if int():
@@ -1256,19 +1261,19 @@ reveal_type(Foo().Meta.name)  # N: Revealed type is "builtins.str"
 
 class A:
     def __init__(self):
-        self.x = None # type: int  # N: By default the bodies of untyped functions are not checked, consider using --check-untyped-defs
-a = None # type: A
+        self.x: int  # N: By default the bodies of untyped functions are not checked, consider using --check-untyped-defs
+a: A
 a.x = 1
 a.x = '' # E: Incompatible types in assignment (expression has type "str", variable has type "int")
 
 [case testAccessAttributeDeclaredInInitBeforeDeclaration]
 
-a = None # type: A
+a: A
 a.x = 1
 a.x = '' # E: Incompatible types in assignment (expression has type "str", variable has type "int")
 class A:
     def __init__(self):
-        self.x = None # type: int  # N: By default the bodies of untyped functions are not checked, consider using --check-untyped-defs
+        self.x: int  # N: By default the bodies of untyped functions are not checked, consider using --check-untyped-defs
 
 
 -- Special cases
@@ -1960,8 +1965,8 @@ from typing import _promote
 class A: pass
 @_promote(A)
 class B: pass
-a = None  # type: A
-b = None  # type: B
+a: A
+b: B
 if int():
     b = a # E: Incompatible types in assignment (expression has type "A", variable has type "B")
     a = b
@@ -1974,8 +1979,8 @@ class A: pass
 class B: pass
 @_promote(B)
 class C: pass
-a = None  # type: A
-c = None  # type: C
+a: A
+c: C
 if int():
     c = a # E: Incompatible types in assignment (expression has type "A", variable has type "C")
     a = c
@@ -2734,8 +2739,8 @@ main:8: note: This violates the Liskov substitution principle
 main:8: note: See https://mypy.readthedocs.io/en/stable/common_issues.html#incompatible-overrides
 
 [case testGetattribute]
-
-a, b = None, None # type: A, B
+a: A
+b: B
 class A:
     def __getattribute__(self, x: str) -> A:
         return A()
@@ -2790,8 +2795,8 @@ main:4: error: Invalid signature "Callable[[B, A], B]" for "__getattribute__"
 main:6: error: Invalid signature "Callable[[C, str, str], C]" for "__getattribute__"
 
 [case testGetattr]
-
-a, b = None, None # type: A, B
+a: A
+b: B
 class A:
     def __getattr__(self, x: str) -> A:
         return A()
@@ -3072,8 +3077,9 @@ C(bar='') # E: Unexpected keyword argument "bar" for "C"
 [builtins fixtures/__new__.pyi]
 
 [case testClassWith__new__AndCompatibilityWithType]
+from typing import Optional
 class C:
-    def __new__(cls, foo: int = None) -> 'C':
+    def __new__(cls, foo: Optional[int] = None) -> 'C':
         obj = object.__new__(cls)
         return obj
 def f(x: type) -> None: pass
@@ -3596,15 +3602,15 @@ main:7: note: Revealed type is "builtins.list[Type[__main__.B]]"
 [case testTypeEquivalentTypeAny]
 from typing import Type, Any
 
-a = None # type: Type[Any]
+a: Type[Any]
 b = a # type: type
 
-x = None # type: type
+x: type
 y = x # type: Type[Any]
 
 class C: ...
 
-p = None # type: type
+p: type
 q = p # type: Type[C]
 
 [builtins fixtures/list.pyi]
@@ -3614,9 +3620,9 @@ q = p # type: Type[C]
 from typing import Type, Any, TypeVar, Generic
 
 class C: ...
-x = None # type: type
-y = None # type: Type[Any]
-z = None # type: Type[C]
+x: type
+y: Type[Any]
+z: Type[C]
 
 lst = [x, y, z]
 reveal_type(lst) # N: Revealed type is "builtins.list[builtins.type]"
@@ -4994,7 +5000,7 @@ a[0]()  # E: "int" not callable
 
 [file m.py]
 from typing import Tuple
-a = None # type: A
+a: A
 class A(Tuple[int, str]): pass
 [builtins fixtures/tuple.pyi]
 
@@ -5102,6 +5108,7 @@ Foos = NewType('Foos', List[Foo]) # type: ignore
 
 def frob(foos: Dict[Any, Foos]) -> None:
     foo = foos.get(1)
+    assert foo
     dict(foo)
 [builtins fixtures/dict.pyi]
 [out]
@@ -5116,6 +5123,7 @@ x: C
 class C:
     def frob(self, foos: Dict[Any, Foos]) -> None:
         foo = foos.get(1)
+        assert foo
         dict(foo)
 
 reveal_type(x.frob) # N: Revealed type is "def (foos: builtins.dict[Any, __main__.Foos])"
diff --git a/test-data/unit/check-enum.test b/test-data/unit/check-enum.test
index b62ed3d942106..ce7e173f635d4 100644
--- a/test-data/unit/check-enum.test
+++ b/test-data/unit/check-enum.test
@@ -297,7 +297,7 @@ f(E.X)
 from enum import IntEnum
 class E(IntEnum):
     a = 1
-x = None  # type: int
+x: int
 reveal_type(E(x))
 [out]
 main:5: note: Revealed type is "__main__.E"
@@ -306,7 +306,7 @@ main:5: note: Revealed type is "__main__.E"
 from enum import IntEnum
 class E(IntEnum):
     a = 1
-s = None  # type: str
+s: str
 reveal_type(E[s])
 [out]
 main:5: note: Revealed type is "__main__.E"

From d4865b25dc6653f5d0a94a17d1fc8c445192bb32 Mon Sep 17 00:00:00 2001
From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
Date: Wed, 5 Jul 2023 20:57:34 +0200
Subject: [PATCH 118/129] Enable strict optional for more test files (2)
 (#15596)

---
 mypy/test/testcheck.py                   | 13 ----------
 test-data/unit/check-formatting.test     | 15 +++++++++---
 test-data/unit/check-incremental.test    |  8 +++---
 test-data/unit/check-inline-config.test  | 31 ++++++++++++------------
 test-data/unit/check-lists.test          | 20 +++++++++++----
 test-data/unit/check-newsemanal.test     |  1 +
 test-data/unit/check-protocols.test      | 17 ++++++++-----
 test-data/unit/check-selftype.test       |  9 ++++---
 test-data/unit/check-serialize.test      |  1 +
 test-data/unit/check-super.test          |  9 ++++---
 test-data/unit/check-type-aliases.test   |  6 ++---
 test-data/unit/check-type-checks.test    |  6 ++---
 test-data/unit/check-typeddict.test      | 12 ++++-----
 test-data/unit/check-typevar-values.test | 30 +++++++++++------------
 14 files changed, 97 insertions(+), 81 deletions(-)

diff --git a/mypy/test/testcheck.py b/mypy/test/testcheck.py
index c9e66e4270b63..1e5c47c2be25e 100644
--- a/mypy/test/testcheck.py
+++ b/mypy/test/testcheck.py
@@ -55,33 +55,20 @@
     "check-bound.test",
     "check-dynamic-typing.test",
     "check-expressions.test",
-    "check-formatting.test",
     "check-functions.test",
     "check-generic-subtyping.test",
     "check-generics.test",
-    "check-incremental.test",
     "check-inference-context.test",
     "check-inference.test",
-    "check-inline-config.test",
     "check-isinstance.test",
     "check-kwargs.test",
-    "check-lists.test",
     "check-literal.test",
     "check-modules.test",
     "check-namedtuple.test",
-    "check-newsemanal.test",
     "check-overloading.test",
     "check-plugin-attrs.test",
-    "check-protocols.test",
-    "check-selftype.test",
-    "check-serialize.test",
     "check-statements.test",
-    "check-super.test",
     "check-tuples.test",
-    "check-type-aliases.test",
-    "check-type-checks.test",
-    "check-typeddict.test",
-    "check-typevar-values.test",
     "check-unions.test",
     "check-varargs.test",
 }
diff --git a/test-data/unit/check-formatting.test b/test-data/unit/check-formatting.test
index 588b2c11714e4..f63abbb330348 100644
--- a/test-data/unit/check-formatting.test
+++ b/test-data/unit/check-formatting.test
@@ -4,7 +4,10 @@
 
 [case testStringInterpolationType]
 from typing import Tuple
-i, f, s, t = None, None, None, None # type: (int, float, str, Tuple[int])
+i: int
+f: float
+s: str
+t: Tuple[int]
 '%d' % i
 '%f' % f
 '%s' % s
@@ -21,7 +24,9 @@ i, f, s, t = None, None, None, None # type: (int, float, str, Tuple[int])
 
 [case testStringInterpolationSAcceptsAnyType]
 from typing import Any
-i, o, s = None, None, None # type: (int, object, str)
+i: int
+o: object
+s: str
 '%s %s %s' % (i, o, s)
 [builtins fixtures/primitives.pyi]
 
@@ -139,8 +144,10 @@ class BytesThing:
     def __getitem__(self, __key: bytes) -> str:
         ...
 
-a = None # type: Any
-ds, do, di = None, None, None # type: Dict[str, int], Dict[object, int], Dict[int, int]
+a: Any
+ds: Dict[str, int]
+do: Dict[object, int]
+di: Dict[int, int]
 '%(a)' % 1  # E: Format requires a mapping (expression has type "int", expected type for mapping is "SupportsKeysAndGetItem[str, Any]")
 '%()d' % a
 '%()d' % ds
diff --git a/test-data/unit/check-incremental.test b/test-data/unit/check-incremental.test
index c3153cd8643aa..5203b0828122e 100644
--- a/test-data/unit/check-incremental.test
+++ b/test-data/unit/check-incremental.test
@@ -1734,12 +1734,12 @@ class R: pass
 [file r/s.py]
 from . import m
 R = m.R
-a = None  # type: R
+a: R
 
 [file r/s.py.2]
 from . import m
 R = m.R
-a = None  # type: R
+a: R
 
 [case testIncrementalBaseClassAttributeConflict]
 class A: pass
@@ -2603,7 +2603,7 @@ def output() -> IntNode[str]:
     return Node(1, 'x')
 x = output() # type: IntNode
 
-y = None # type: IntNode
+y: IntNode
 y.x = 1
 y.y = 1
 y.y = 'x'
@@ -2625,7 +2625,7 @@ def output() -> IntNode[str]:
     return Node(1, 'x')
 x = output() # type: IntNode
 
-y = None # type: IntNode
+y: IntNode
 y.x = 1
 y.y = 1
 y.y = 'x'
diff --git a/test-data/unit/check-inline-config.test b/test-data/unit/check-inline-config.test
index 0cc2bd71270a6..71030b5c9b972 100644
--- a/test-data/unit/check-inline-config.test
+++ b/test-data/unit/check-inline-config.test
@@ -4,8 +4,8 @@
 
 # mypy: disallow-any-generics, no-warn-no-return
 
-from typing import List
-def foo() -> List:  # E: Missing type parameters for generic type "List"
+from typing import List, Optional
+def foo() -> Optional[List]:  # E: Missing type parameters for generic type "List"
     20
 
 [builtins fixtures/list.pyi]
@@ -15,8 +15,8 @@ def foo() -> List:  # E: Missing type parameters for generic type "List"
 # mypy: disallow-any-generics
 # mypy: no-warn-no-return
 
-from typing import List
-def foo() -> List:  # E: Missing type parameters for generic type "List"
+from typing import List, Optional
+def foo() -> Optional[List]:  # E: Missing type parameters for generic type "List"
     20
 
 [builtins fixtures/list.pyi]
@@ -25,8 +25,8 @@ def foo() -> List:  # E: Missing type parameters for generic type "List"
 
 # mypy: disallow-any-generics=true, warn-no-return=0
 
-from typing import List
-def foo() -> List:  # E: Missing type parameters for generic type "List"
+from typing import List, Optional
+def foo() -> Optional[List]:  # E: Missing type parameters for generic type "List"
     20
 
 [builtins fixtures/list.pyi]
@@ -36,8 +36,8 @@ def foo() -> List:  # E: Missing type parameters for generic type "List"
 
 # mypy: disallow-any-generics = true, warn-no-return = 0
 
-from typing import List
-def foo() -> List:  # E: Missing type parameters for generic type "List"
+from typing import List, Optional
+def foo() -> Optional[List]:  # E: Missing type parameters for generic type "List"
     20
 
 [builtins fixtures/list.pyi]
@@ -84,20 +84,20 @@ import a
 [file a.py]
 # mypy: disallow-any-generics, no-warn-no-return
 
-from typing import List
-def foo() -> List:
+from typing import List, Optional
+def foo() -> Optional[List]:
     20
 
 [file a.py.2]
 # mypy: no-warn-no-return
 
-from typing import List
-def foo() -> List:
+from typing import List, Optional
+def foo() -> Optional[List]:
     20
 
 [file a.py.3]
-from typing import List
-def foo() -> List:
+from typing import List, Optional
+def foo() -> Optional[List]:
     20
 [out]
 tmp/a.py:4: error: Missing type parameters for generic type "List"
@@ -131,8 +131,9 @@ tmp/a.py:4: error: Missing type parameters for generic type "List"
 import a, b
 [file a.py]
 # mypy: no-warn-no-return
+from typing import Optional
 
-def foo() -> int:
+def foo() -> Optional[int]:
     20
 
 [file b.py]
diff --git a/test-data/unit/check-lists.test b/test-data/unit/check-lists.test
index 899b7c5b209fc..9809024afdbbe 100644
--- a/test-data/unit/check-lists.test
+++ b/test-data/unit/check-lists.test
@@ -3,8 +3,12 @@
 
 [case testNestedListAssignment]
 from typing import List
-a1, b1, c1 = None, None, None # type: (A, B, C)
-a2, b2, c2 = None, None, None # type: (A, B, C)
+a1: A
+a2: A
+b1: B
+b2: B
+c1: C
+c2: C
 
 if int():
     a1, [b1, c1] = a2, [b2, c2]
@@ -21,7 +25,9 @@ class C: pass
 
 [case testNestedListAssignmentToTuple]
 from typing import List
-a, b, c = None, None, None # type: (A, B, C)
+a: A
+b: B
+c: C
 
 a, b = [a, b]
 a, b = [a]  # E: Need more than 1 value to unpack (2 expected)
@@ -35,7 +41,9 @@ class C: pass
 
 [case testListAssignmentFromTuple]
 from typing import List
-a, b, c = None, None, None # type: (A, B, C)
+a: A
+b: B
+c: C
 t = a, b
 
 if int():
@@ -55,7 +63,9 @@ class C: pass
 
 [case testListAssignmentUnequalAmountToUnpack]
 from typing import List
-a, b, c = None, None, None # type: (A, B, C)
+a: A
+b: B
+c: C
 
 def f() -> None: # needed because test parser tries to parse [a, b] as section header
     [a, b] = [a, b]
diff --git a/test-data/unit/check-newsemanal.test b/test-data/unit/check-newsemanal.test
index de8212b3e6950..77a1553d47155 100644
--- a/test-data/unit/check-newsemanal.test
+++ b/test-data/unit/check-newsemanal.test
@@ -2149,6 +2149,7 @@ x: C
 class C:
     def frob(self, foos: Dict[Any, Foos]) -> None:
         foo = foos.get(1)
+        assert foo
         dict(foo)
 [builtins fixtures/dict.pyi]
 
diff --git a/test-data/unit/check-protocols.test b/test-data/unit/check-protocols.test
index 6ba1fde4d022f..5d5ba54304a3a 100644
--- a/test-data/unit/check-protocols.test
+++ b/test-data/unit/check-protocols.test
@@ -319,7 +319,9 @@ class MyHashable(Protocol):
 class C:
     __my_hash__ = None
 
-var: MyHashable = C()  # E: Incompatible types in assignment (expression has type "C", variable has type "MyHashable")
+var: MyHashable = C()  # E: Incompatible types in assignment (expression has type "C", variable has type "MyHashable") \
+                       # N: Following member(s) of "C" have conflicts: \
+                       # N:     __my_hash__: expected "Callable[[], int]", got "None"
 
 [case testNoneDisablesProtocolSubclassingWithStrictOptional]
 # flags: --strict-optional
@@ -1263,13 +1265,13 @@ if int():
 [builtins fixtures/classmethod.pyi]
 
 [case testOverloadedMethodsInProtocols]
-from typing import overload, Protocol, Union
+from typing import overload, Protocol, Union, Optional
 
 class P(Protocol):
     @overload
-    def f(self, x: int) -> int: pass
+    def f(self, x: int) -> Optional[int]: pass
     @overload
-    def f(self, x: str) -> str: pass
+    def f(self, x: str) -> Optional[str]: pass
 
 class C:
     def f(self, x: Union[int, str]) -> None:
@@ -1286,9 +1288,9 @@ main:18: error: Incompatible types in assignment (expression has type "D", varia
 main:18: note: Following member(s) of "D" have conflicts:
 main:18: note:     Expected:
 main:18: note:         @overload
-main:18: note:         def f(self, x: int) -> int
+main:18: note:         def f(self, x: int) -> Optional[int]
 main:18: note:         @overload
-main:18: note:         def f(self, x: str) -> str
+main:18: note:         def f(self, x: str) -> Optional[str]
 main:18: note:     Got:
 main:18: note:         def f(self, x: int) -> None
 
@@ -1441,6 +1443,7 @@ def g(x: P, y: P2) -> None: pass
 reveal_type(f(g)) # N: Revealed type is "__main__.P2"
 
 [case testMeetOfIncompatibleProtocols]
+# flags: --no-strict-optional
 from typing import Protocol, Callable, TypeVar
 
 class P(Protocol):
@@ -1634,6 +1637,7 @@ f(Alias)  # E: Only concrete class can be given where "Type[P]" is expected
 f(GoodAlias)
 
 [case testInstantiationProtocolInTypeForVariables]
+# flags: --no-strict-optional
 from typing import Type, Protocol
 
 class P(Protocol):
@@ -2397,6 +2401,7 @@ x: P = None
 [out]
 
 [case testNoneSubtypeOfAllProtocolsWithoutStrictOptional]
+# flags: --no-strict-optional
 from typing import Protocol
 class P(Protocol):
     attr: int
diff --git a/test-data/unit/check-selftype.test b/test-data/unit/check-selftype.test
index dc7a6c239fe61..d366e7c337992 100644
--- a/test-data/unit/check-selftype.test
+++ b/test-data/unit/check-selftype.test
@@ -897,7 +897,8 @@ class Base(Protocol):
 
 class TweakFunc:
     def func(self: Base) -> int:
-        return reveal_type(super().func())  # N: Revealed type is "builtins.int"
+        return reveal_type(super().func())  # E: Call to abstract method "func" of "Base" with trivial body via super() is unsafe \
+                                            # N: Revealed type is "builtins.int"
 
 class Good:
     def func(self) -> int: ...
@@ -1269,14 +1270,14 @@ class AClass:
         ...
 
 def foo(x: Type[AClass]) -> None:
-    reveal_type(x.delete)  # N: Revealed type is "Overload(def (id: builtins.int, id2: builtins.int) -> builtins.int, def (id: __main__.AClass, id2: None =) -> builtins.int)"
+    reveal_type(x.delete)  # N: Revealed type is "Overload(def (id: builtins.int, id2: builtins.int) -> Union[builtins.int, None], def (id: __main__.AClass, id2: None =) -> Union[builtins.int, None])"
     y = x()
-    reveal_type(y.delete)  # N: Revealed type is "Overload(def (id: builtins.int, id2: builtins.int) -> builtins.int, def (id: __main__.AClass, id2: None =) -> builtins.int)"
+    reveal_type(y.delete)  # N: Revealed type is "Overload(def (id: builtins.int, id2: builtins.int) -> Union[builtins.int, None], def (id: __main__.AClass, id2: None =) -> Union[builtins.int, None])"
     y.delete(10, 20)
     y.delete(y)
 
 def bar(x: AClass) -> None:
-    reveal_type(x.delete)  # N: Revealed type is "Overload(def (id: builtins.int, id2: builtins.int) -> builtins.int, def (id: __main__.AClass, id2: None =) -> builtins.int)"
+    reveal_type(x.delete)  # N: Revealed type is "Overload(def (id: builtins.int, id2: builtins.int) -> Union[builtins.int, None], def (id: __main__.AClass, id2: None =) -> Union[builtins.int, None])"
     x.delete(10, 20)
 [builtins fixtures/classmethod.pyi]
 
diff --git a/test-data/unit/check-serialize.test b/test-data/unit/check-serialize.test
index 66d5d879ae681..e5d1d6b170f91 100644
--- a/test-data/unit/check-serialize.test
+++ b/test-data/unit/check-serialize.test
@@ -1275,6 +1275,7 @@ main:2: error: Too many arguments for "f"
 main:2: error: Too many arguments for "f"
 
 [case testSerializeDummyType]
+# flags: --no-strict-optional
 import a
 [file a.py]
 import b
diff --git a/test-data/unit/check-super.test b/test-data/unit/check-super.test
index b3379e505be72..48a0a0250ecf5 100644
--- a/test-data/unit/check-super.test
+++ b/test-data/unit/check-super.test
@@ -11,7 +11,8 @@ class B:
   def f(self) -> 'B': pass
 class A(B):
   def f(self) -> 'A':
-    a, b = None, None # type: (A, B)
+    a: A
+    b: B
     if int():
         a = super().f() # E: Incompatible types in assignment (expression has type "B", variable has type "A")
         a = super().g() # E: "g" undefined in superclass
@@ -26,7 +27,8 @@ class B:
   def f(self, y: 'A') -> None: pass
 class A(B):
   def f(self, y: Any) -> None:
-    a, b = None, None # type: (A, B)
+    a: A
+    b: B
     super().f(b) # E: Argument 1 to "f" of "B" has incompatible type "B"; expected "A"
     super().f(a)
     self.f(b)
@@ -35,6 +37,7 @@ class A(B):
 [out]
 
 [case testAccessingSuperInit]
+# flags: --no-strict-optional
 import typing
 class B:
     def __init__(self, x: A) -> None: pass
@@ -90,7 +93,7 @@ class B(A):
     def __new__(cls, x: int, y: str = '') -> 'B':
         super().__new__(cls, 1)
         super().__new__(cls, 1, '')  # E: Too many arguments for "__new__" of "A"
-        return None
+        return cls(1)
 B('')  # E: Argument 1 to "B" has incompatible type "str"; expected "int"
 B(1)
 B(1, 'x')
diff --git a/test-data/unit/check-type-aliases.test b/test-data/unit/check-type-aliases.test
index 05a03ecaf7b09..3bfcf6a9afeae 100644
--- a/test-data/unit/check-type-aliases.test
+++ b/test-data/unit/check-type-aliases.test
@@ -28,7 +28,7 @@ f(1) # E: Argument 1 to "f" has incompatible type "int"; expected "Tuple[int, st
 [case testCallableTypeAlias]
 from typing import Callable
 A = Callable[[int], None]
-f = None  # type: A
+f: A
 f(1)
 f('') # E: Argument 1 has incompatible type "str"; expected "int"
 [targets __main__]
@@ -169,11 +169,11 @@ f(1) # E: Argument 1 to "f" has incompatible type "int"; expected "str"
 [case testEmptyTupleTypeAlias]
 from typing import Tuple, Callable
 EmptyTuple = Tuple[()]
-x = None # type: EmptyTuple
+x: EmptyTuple
 reveal_type(x)  # N: Revealed type is "Tuple[]"
 
 EmptyTupleCallable = Callable[[Tuple[()]], None]
-f = None # type: EmptyTupleCallable
+f: EmptyTupleCallable
 reveal_type(f)  # N: Revealed type is "def (Tuple[])"
 [builtins fixtures/list.pyi]
 
diff --git a/test-data/unit/check-type-checks.test b/test-data/unit/check-type-checks.test
index 106f2d680ba45..03c8de4177f3b 100644
--- a/test-data/unit/check-type-checks.test
+++ b/test-data/unit/check-type-checks.test
@@ -2,9 +2,9 @@
 
 
 [case testSimpleIsinstance]
-x = None  # type: object
-n = None  # type: int
-s = None  # type: str
+x: object
+n: int
+s: str
 if int():
     n = x # E: Incompatible types in assignment (expression has type "object", variable has type "int")
 if isinstance(x, int):
diff --git a/test-data/unit/check-typeddict.test b/test-data/unit/check-typeddict.test
index 4d2d648485153..739d1ba6eb751 100644
--- a/test-data/unit/check-typeddict.test
+++ b/test-data/unit/check-typeddict.test
@@ -1121,8 +1121,8 @@ D = TypedDict('D', {'x': int, 'y': str}, total=False)
 d: D
 reveal_type(d['x']) # N: Revealed type is "builtins.int"
 reveal_type(d['y']) # N: Revealed type is "builtins.str"
-reveal_type(d.get('x')) # N: Revealed type is "builtins.int"
-reveal_type(d.get('y')) # N: Revealed type is "builtins.str"
+reveal_type(d.get('x')) # N: Revealed type is "Union[builtins.int, None]"
+reveal_type(d.get('y')) # N: Revealed type is "Union[builtins.str, None]"
 [builtins fixtures/dict.pyi]
 [typing fixtures/typing-typeddict.pyi]
 
@@ -1642,7 +1642,7 @@ def f1(x: int, y: str, z: bytes) -> None: ...
 def f2(x: int, y: str) -> None: ...
 
 td: TD
-d = None # type: Dict[Any, Any]
+d: Dict[Any, Any]
 
 f1(**td, **d)
 f1(**d, **td)
@@ -1740,8 +1740,8 @@ class TDB(TypedDict):
 
 td: Union[TDA, TDB]
 
-reveal_type(td.get('a'))  # N: Revealed type is "builtins.int"
-reveal_type(td.get('b'))  # N: Revealed type is "Union[builtins.str, builtins.int]"
+reveal_type(td.get('a'))  # N: Revealed type is "Union[builtins.int, None]"
+reveal_type(td.get('b'))  # N: Revealed type is "Union[builtins.str, None, builtins.int]"
 reveal_type(td.get('c'))  # N: Revealed type is "builtins.object"
 
 reveal_type(td['a'])  # N: Revealed type is "builtins.int"
@@ -1805,7 +1805,7 @@ from mypy_extensions import TypedDict
 class A(TypedDict):
     x: int
 
-d: Union[A, None]
+d: A
 d.update({'x': 1})
 [builtins fixtures/dict.pyi]
 
diff --git a/test-data/unit/check-typevar-values.test b/test-data/unit/check-typevar-values.test
index 83340c52b63b9..effaf620f1f0b 100644
--- a/test-data/unit/check-typevar-values.test
+++ b/test-data/unit/check-typevar-values.test
@@ -97,8 +97,8 @@ def f(x: AB) -> AB:
 from typing import TypeVar
 T = TypeVar('T', int, str)
 def f(x: T) -> T:
-    a = None  # type: T
-    b = None # type: T
+    a: T
+    b: T
     if 1:
         a = x
         b = x
@@ -248,10 +248,10 @@ def g(a: T) -> None:
 from typing import TypeVar, Generic, Any
 X = TypeVar('X', int, str)
 class A(Generic[X]): pass
-a = None  # type: A[int]
-b = None  # type: A[str]
-d = None  # type: A[object] # E: Value of type variable "X" of "A" cannot be "object"
-c = None  # type: A[Any]
+a: A[int]
+b: A[str]
+d: A[object]  # E: Value of type variable "X" of "A" cannot be "object"
+c: A[Any]
 
 [case testConstructGenericTypeWithTypevarValuesAndTypeInference]
 from typing import TypeVar, Generic, Any, cast
@@ -272,11 +272,11 @@ Z = TypeVar('Z')
 class D(Generic[X]):
     def __init__(self, x: X) -> None: pass
 def f(x: X) -> None:
-    a = None  # type: D[X]
+    a: D[X]
 def g(x: Y) -> None:
-    a = None  # type: D[Y]
+    a: D[Y]
 def h(x: Z) -> None:
-    a = None  # type: D[Z]
+    a: D[Z]
 [out]
 main:11: error: Invalid type argument value for "D"
 main:13: error: Type variable "Z" not valid as type argument value for "D"
@@ -287,7 +287,7 @@ X = TypeVar('X', int, str)
 class S(str): pass
 class C(Generic[X]):
     def __init__(self, x: X) -> None: pass
-x = None  # type: C[str]
+x: C[str]
 y = C(S())
 if int():
     x = y
@@ -412,10 +412,10 @@ class B: pass
 X = TypeVar('X', A, B)
 Y = TypeVar('Y', int, str)
 class C(Generic[X, Y]): pass
-a = None  # type: C[A, int]
-b = None  # type: C[B, str]
-c = None  # type: C[int, int] # E: Value of type variable "X" of "C" cannot be "int"
-d = None  # type: C[A, A]     # E: Value of type variable "Y" of "C" cannot be "A"
+a: C[A, int]
+b: C[B, str]
+c: C[int, int]  # E: Value of type variable "X" of "C" cannot be "int"
+d: C[A, A]      # E: Value of type variable "Y" of "C" cannot be "A"
 
 [case testCallGenericFunctionUsingMultipleTypevarsWithValues]
 from typing import TypeVar
@@ -512,7 +512,7 @@ class C(A[str]):
 from typing import TypeVar, Generic
 T = TypeVar('T', int, str)
 class C(Generic[T]):
-    def f(self, x: int = None) -> None: pass
+    def f(self, x: int = 2) -> None: pass
 
 [case testTypevarValuesWithOverloadedFunctionSpecialCase]
 from foo import *

From fae7d90c7f18d44f7ebe7c25d63325c9811e9fe0 Mon Sep 17 00:00:00 2001
From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
Date: Thu, 6 Jul 2023 01:38:29 +0200
Subject: [PATCH 119/129] Enable strict optional for more test files (4)
 (#15601)

---
 mypy/test/testcheck.py                   |   3 -
 test-data/unit/check-basic.test          |  26 ++--
 test-data/unit/check-bound.test          |  10 +-
 test-data/unit/check-dynamic-typing.test | 155 ++++++++++++-----------
 4 files changed, 99 insertions(+), 95 deletions(-)

diff --git a/mypy/test/testcheck.py b/mypy/test/testcheck.py
index 1e5c47c2be25e..e00ae047ae8dd 100644
--- a/mypy/test/testcheck.py
+++ b/mypy/test/testcheck.py
@@ -51,9 +51,6 @@
 
 # TODO: Enable strict optional in test cases by default. Remove files here, once test cases are updated
 no_strict_optional_files = {
-    "check-basic.test",
-    "check-bound.test",
-    "check-dynamic-typing.test",
     "check-expressions.test",
     "check-functions.test",
     "check-generic-subtyping.test",
diff --git a/test-data/unit/check-basic.test b/test-data/unit/check-basic.test
index e10e69267c5a3..408c3599672b9 100644
--- a/test-data/unit/check-basic.test
+++ b/test-data/unit/check-basic.test
@@ -2,8 +2,8 @@
 [out]
 
 [case testAssignmentAndVarDef]
-a = None # type: A
-b = None # type: B
+a: A
+b: B
 if int():
     a = a
 if int():
@@ -17,14 +17,14 @@ class A:
 class B:
     def __init__(self): pass
 
-x = None # type: A
+x: A
 x = A()
 if int():
     x = B() # E: Incompatible types in assignment (expression has type "B", variable has type "A")
 [case testInheritInitFromObject]
 class A(object): pass
 class B(object): pass
-x = None # type: A
+x: A
 if int():
     x = A()
 if int():
@@ -32,8 +32,8 @@ if int():
 [case testImplicitInheritInitFromObject]
 class A: pass
 class B: pass
-x = None # type: A
-o = None # type: object
+x: A
+o: object
 if int():
     x = o # E: Incompatible types in assignment (expression has type "object", variable has type "A")
 if int():
@@ -59,7 +59,7 @@ x = B() # type: A
 y = A() # type: B  # E: Incompatible types in assignment (expression has type "A", variable has type "B")
 [case testDeclaredVariableInParentheses]
 
-(x) = None # type: int
+(x) = 2 # type: int
 if int():
     x = '' # E: Incompatible types in assignment (expression has type "str", variable has type "int")
 if int():
@@ -135,8 +135,8 @@ main:6: error: Missing positional arguments "baz", "bas" in call to "foo"
 
 [case testLocalVariables]
 def f() -> None:
-  x = None # type: A
-  y = None # type: B
+  x: A
+  y: B
   if int():
       x = x
       x = y # E: Incompatible types in assignment (expression has type "B", variable has type "A")
@@ -229,12 +229,12 @@ reveal_type(__annotations__)  # N: Revealed type is "builtins.dict[builtins.str,
 [case testLocalVariableShadowing]
 class A: pass
 class B: pass
-a = None # type: A
+a: A
 if int():
     a = B()  # E: Incompatible types in assignment (expression has type "B", variable has type "A")
     a = A()
 def f() -> None:
-  a = None # type: B
+  a: B
   if int():
       a = A()     # E: Incompatible types in assignment (expression has type "A", variable has type "B")
       a = B()
@@ -242,8 +242,8 @@ a = B()       # E: Incompatible types in assignment (expression has type "B", va
 a = A()
 [case testGlobalDefinedInBlockWithType]
 class A: pass
-while A:
-    a = None # type: A
+while 1:
+    a: A
     if int():
         a = A()
         a = object() # E: Incompatible types in assignment (expression has type "object", variable has type "A")
diff --git a/test-data/unit/check-bound.test b/test-data/unit/check-bound.test
index eb97bde32e1f6..1c713fd77c38d 100644
--- a/test-data/unit/check-bound.test
+++ b/test-data/unit/check-bound.test
@@ -37,15 +37,16 @@ T = TypeVar('T', bound=A)
 class G(Generic[T]):
     def __init__(self, x: T) -> None: pass
 
-v = None # type: G[A]
-w = None # type: G[B]
-x = None # type: G[str] # E: Type argument "str" of "G" must be a subtype of "A"
+v: G[A]
+w: G[B]
+x: G[str]  # E: Type argument "str" of "G" must be a subtype of "A"
 y = G('a') # E: Value of type variable "T" of "G" cannot be "str"
 z = G(A())
 z = G(B())
 
 
 [case testBoundVoid]
+# flags: --no-strict-optional
 from typing import TypeVar, Generic
 T = TypeVar('T', bound=int)
 class C(Generic[T]):
@@ -70,10 +71,11 @@ def g(): pass
 
 f(g())
 C(g())
-z = None # type: C
+z: C
 
 
 [case testBoundHigherOrderWithVoid]
+# flags: --no-strict-optional
 from typing import TypeVar, Callable
 class A: pass
 T = TypeVar('T', bound=A)
diff --git a/test-data/unit/check-dynamic-typing.test b/test-data/unit/check-dynamic-typing.test
index dd4cc1579639e..0dc05a7a0ea13 100644
--- a/test-data/unit/check-dynamic-typing.test
+++ b/test-data/unit/check-dynamic-typing.test
@@ -4,8 +4,8 @@
 
 [case testAssignmentWithDynamic]
 from typing import Any
-d = None # type: Any
-a = None # type: A
+d: Any
+a: A
 
 if int():
     a = d # Everything ok
@@ -20,8 +20,9 @@ class A: pass
 
 [case testMultipleAssignmentWithDynamic]
 from typing import Any
-d = None # type: Any
-a, b = None, None # type: (A, B)
+d: Any
+a: A
+b: B
 
 if int():
     d, a = b, b    # E: Incompatible types in assignment (expression has type "B", variable has type "A")
@@ -51,7 +52,8 @@ from typing import Any
 def f(x: Any) -> 'A':
     pass
 
-a, b = None, None # type: (A, B)
+a: A
+b: B
 
 if int():
     b = f(a) # E: Incompatible types in assignment (expression has type "A", variable has type "B")
@@ -75,7 +77,8 @@ from typing import Any
 def f(x: 'A') -> Any:
     pass
 
-a, b = None, None # type: (A, B)
+a: A
+b: B
 
 a = f(b) # E: Argument 1 to "f" has incompatible type "B"; expected "A"
 
@@ -88,10 +91,10 @@ class B: pass
 
 [case testBinaryOperationsWithDynamicLeftOperand]
 from typing import Any
-d = None # type: Any
-a = None # type: A
-c = None # type: C
-b = None # type: bool
+d: Any
+a: A
+c: C
+b: bool
 n = 0
 
 d in a  # E: Unsupported right operand type for in ("A")
@@ -151,10 +154,10 @@ class dict: pass
 
 [case testBinaryOperationsWithDynamicAsRightOperand]
 from typing import Any
-d = None # type: Any
-a = None # type: A
-c = None # type: C
-b = None # type: bool
+d: Any
+a: A
+c: C
+b: bool
 n = 0
 
 a and d
@@ -224,9 +227,9 @@ class dict: pass
 
 [case testDynamicWithUnaryExpressions]
 from typing import Any
-d = None # type: Any
-a = None # type: A
-b = None # type: bool
+d: Any
+a: A
+b: bool
 if int():
     a = not d # E: Incompatible types in assignment (expression has type "bool", variable has type "A")
 if int():
@@ -238,8 +241,8 @@ class A: pass
 
 [case testDynamicWithMemberAccess]
 from typing import Any
-d = None # type: Any
-a = None # type: A
+d: Any
+a: A
 
 if int():
     a = d.foo(a()) # E: "A" not callable
@@ -256,8 +259,8 @@ class A: pass
 
 [case testIndexingWithDynamic]
 from typing import Any
-d = None # type: Any
-a = None # type: A
+d: Any
+a: A
 
 if int():
     a = d[a()] # E: "A" not callable
@@ -270,10 +273,10 @@ d[a], d[a] = a, a
 
 class A: pass
 
-[case testTupleExpressionsWithDynamci]
+[case testTupleExpressionsWithDynamic]
 from typing import Tuple, Any
-t2 = None # type: Tuple[A, A]
-d = None # type: Any
+t2: Tuple[A, A]
+d: Any
 
 if int():
     t2 = (d, d, d)  # E: Incompatible types in assignment (expression has type "Tuple[Any, Any, Any]", variable has type "Tuple[A, A]")
@@ -289,9 +292,9 @@ class A: pass
 class B: pass
 def f() -> None: pass
 
-d = None # type: Any
-a = None # type: A
-b = None # type: B
+d: Any
+a: A
+b: B
 if int():
     b = cast(A, d) # E: Incompatible types in assignment (expression has type "A", variable has type "B")
 if int():
@@ -309,8 +312,8 @@ def g(a: 'A') -> None:
 class A: pass
 class B: pass
 
-d = None # type: Any
-t = None # type: Tuple[A, A]
+d: Any
+t: Tuple[A, A]
 # TODO: callable types, overloaded functions
 
 d = None # All ok
@@ -362,10 +365,10 @@ class A: pass
 
 [case testImplicitGlobalFunctionSignature]
 from typing import Any, Callable
-x = None # type: Any
-a = None # type: A
-g = None # type: Callable[[], None]
-h = None # type: Callable[[A], None]
+x: Any
+a: A
+g: Callable[[], None]
+h: Callable[[A], None]
 
 def f(x): pass
 
@@ -384,10 +387,10 @@ class A: pass
 
 [case testImplicitGlobalFunctionSignatureWithDifferentArgCounts]
 from typing import Callable
-g0 = None # type: Callable[[], None]
-g1 = None # type: Callable[[A], None]
-g2 = None # type: Callable[[A, A], None]
-a = None # type: A
+g0: Callable[[], None]
+g1: Callable[[A], None]
+g2: Callable[[A, A], None]
+a: A
 
 def f0(): pass
 def f2(x, y): pass
@@ -415,16 +418,17 @@ from typing import Callable
 class A: pass
 class B: pass
 
-a, b = None, None # type: (A, B)
+a: A
+b: B
 
 def f01(x = b): pass
 def f13(x, y = b, z = b): pass
 
-g0 = None # type: Callable[[], None]
-g1 = None # type: Callable[[A], None]
-g2 = None # type: Callable[[A, A], None]
-g3 = None # type: Callable[[A, A, A], None]
-g4 = None # type: Callable[[A, A, A, A], None]
+g0: Callable[[], None]
+g1: Callable[[A], None]
+g2: Callable[[A, A], None]
+g3: Callable[[A, A, A], None]
+g4: Callable[[A, A, A, A], None]
 
 f01(a, a)       # E: Too many arguments for "f01"
 f13()           # E: Missing positional argument "x" in call to "f13"
@@ -456,7 +460,7 @@ if int():
 [builtins fixtures/tuple.pyi]
 
 [case testSkipTypeCheckingWithImplicitSignature]
-a = None # type: A
+a: A
 def f():
     a()
 def g(x):
@@ -469,7 +473,7 @@ class A: pass
 [builtins fixtures/bool.pyi]
 
 [case testSkipTypeCheckingWithImplicitSignatureAndDefaultArgs]
-a = None # type: A
+a: A
 def f(x=a()):
     a()
 def g(x, y=a, z=a()):
@@ -478,10 +482,10 @@ class A: pass
 
 [case testImplicitMethodSignature]
 from typing import Callable
-g0 = None # type: Callable[[], None]
-g1 = None # type: Callable[[A], None]
-g2 = None # type: Callable[[A, A], None]
-a = None # type: A
+g0: Callable[[], None]
+g1: Callable[[A], None]
+g2: Callable[[A, A], None]
+a: A
 
 if int():
     g0 = a.f # E: Incompatible types in assignment (expression has type "Callable[[Any], Any]", variable has type "Callable[[], None]")
@@ -502,7 +506,7 @@ if int():
 
 [case testSkipTypeCheckingImplicitMethod]
 
-a = None # type: A
+a: A
 class A:
     def f(self):
         a()
@@ -511,9 +515,9 @@ class A:
 
 [case testImplicitInheritedMethod]
 from typing import Callable
-g0 = None # type: Callable[[], None]
-g1 = None # type: Callable[[A], None]
-a = None # type: A
+g0: Callable[[], None]
+g1: Callable[[A], None]
+a: A
 
 if int():
     g0 = a.f # E: Incompatible types in assignment (expression has type "Callable[[Any], Any]", variable has type "Callable[[], None]")
@@ -559,9 +563,9 @@ from typing import Callable
 class A:
   def __init__(self, a, b): pass
 
-f1 = None # type: Callable[[A], A]
-f2 = None # type: Callable[[A, A], A]
-a = None # type: A
+f1: Callable[[A], A]
+f2: Callable[[A, A], A]
+a: A
 
 A(a)   # E: Missing positional argument "b" in call to "A"
 if int():
@@ -576,7 +580,7 @@ class A: pass
 class B:
     def __init__(self): pass
 
-t = None # type: type
+t: type
 t = A
 t = B
 -- Type compatibility
@@ -585,11 +589,11 @@ t = B
 
 [case testTupleTypeCompatibility]
 from typing import Any, Tuple
-t1 = None # type: Tuple[Any, A]
-t2 = None # type: Tuple[A, Any]
-t3 = None # type: Tuple[Any, Any]
-t4 = None # type: Tuple[A, A]
-t5 = None # type: Tuple[Any, Any, Any]
+t1: Tuple[Any, A]
+t2: Tuple[A, Any]
+t3: Tuple[Any, Any]
+t4: Tuple[A, A]
+t5: Tuple[Any, Any, Any]
 
 def f(): t1, t2, t3, t4, t5 # Prevent redefinition
 
@@ -614,11 +618,11 @@ class A: pass
 [builtins fixtures/tuple.pyi]
 
 [case testFunctionTypeCompatibilityAndReturnTypes]
-from typing import Any, Callable
-f1 = None # type: Callable[[], Any]
-f11 = None # type: Callable[[], Any]
-f2 = None # type: Callable[[], A]
-f3 = None # type: Callable[[], None]
+from typing import Any, Callable, Optional
+f1: Callable[[], Any]
+f11: Callable[[], Any]
+f2: Callable[[], Optional[A]]
+f3: Callable[[], None]
 
 f2 = f3
 
@@ -631,9 +635,9 @@ class A: pass
 
 [case testFunctionTypeCompatibilityAndArgumentTypes]
 from typing import Any, Callable
-f1 = None # type: Callable[[A, Any], None]
-f2 = None # type: Callable[[Any, A], None]
-f3 = None # type: Callable[[A, A], None]
+f1: Callable[[A, Any], None]
+f2: Callable[[Any, A], None]
+f3: Callable[[A, A], None]
 
 f1 = f1
 f1 = f2
@@ -651,8 +655,8 @@ class A: pass
 
 [case testFunctionTypeCompatibilityAndArgumentCounts]
 from typing import Any, Callable
-f1 = None # type: Callable[[Any], None]
-f2 = None # type: Callable[[Any, Any], None]
+f1: Callable[[Any], None]
+f2: Callable[[Any, Any], None]
 
 if int():
     f1 = f2 # E: Incompatible types in assignment (expression has type "Callable[[Any, Any], None]", variable has type "Callable[[Any], None]")
@@ -664,7 +668,8 @@ if int():
 
 [case testOverridingMethodWithDynamicTypes]
 from typing import Any
-a, b = None, None # type: (A, B)
+a: A
+b: B
 
 b.f(b) # E: Argument 1 to "f" of "B" has incompatible type "B"; expected "A"
 a = a.f(b)
@@ -682,8 +687,8 @@ class A(B):
 [builtins fixtures/tuple.pyi]
 
 [case testOverridingMethodWithImplicitDynamicTypes]
-
-a, b = None, None # type: (A, B)
+a: A
+b: B
 
 b.f(b) # E: Argument 1 to "f" of "B" has incompatible type "B"; expected "A"
 a = a.f(b)

From fa8853bda7035ef517984b4afbaa6d953318fa9d Mon Sep 17 00:00:00 2001
From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
Date: Thu, 6 Jul 2023 03:03:53 +0200
Subject: [PATCH 120/129] Enable strict optional for more test files (5)
 (#15602)

Followup to https://github.com/python/mypy/pull/15586

Co-authored-by: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
---
 mypy/test/testcheck.py                |   1 -
 test-data/unit/check-expressions.test | 251 ++++++++++++++++----------
 2 files changed, 156 insertions(+), 96 deletions(-)

diff --git a/mypy/test/testcheck.py b/mypy/test/testcheck.py
index e00ae047ae8dd..47e01910cf2c4 100644
--- a/mypy/test/testcheck.py
+++ b/mypy/test/testcheck.py
@@ -51,7 +51,6 @@
 
 # TODO: Enable strict optional in test cases by default. Remove files here, once test cases are updated
 no_strict_optional_files = {
-    "check-expressions.test",
     "check-functions.test",
     "check-generic-subtyping.test",
     "check-generics.test",
diff --git a/test-data/unit/check-expressions.test b/test-data/unit/check-expressions.test
index 1fa551f6a2e4e..8231b0a3265f5 100644
--- a/test-data/unit/check-expressions.test
+++ b/test-data/unit/check-expressions.test
@@ -13,11 +13,12 @@
 
 [case testNoneAsRvalue]
 import typing
-a = None # type: A
+a: A
 class A: pass
 [out]
 
 [case testNoneAsArgument]
+# flags: --no-strict-optional
 import typing
 def f(x: 'A', y: 'B') -> None: pass
 f(None, None)
@@ -32,7 +33,7 @@ class B(A): pass
 
 [case testIntLiteral]
 a = 0
-b = None # type: A
+b: A
 if int():
     b = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "A")
 if int():
@@ -42,7 +43,7 @@ class A:
 
 [case testStrLiteral]
 a = ''
-b = None # type: A
+b: A
 if int():
     b = 'x' # E: Incompatible types in assignment (expression has type "str", variable has type "A")
 if int():
@@ -56,7 +57,7 @@ class A:
 
 [case testFloatLiteral]
 a = 0.0
-b = None # type: A
+b: A
 if str():
     b = 1.1 # E: Incompatible types in assignment (expression has type "float", variable has type "A")
 if str():
@@ -67,7 +68,7 @@ class A:
 
 [case testComplexLiteral]
 a = 0.0j
-b = None # type: A
+b: A
 if str():
     b = 1.1j # E: Incompatible types in assignment (expression has type "complex", variable has type "A")
 if str():
@@ -77,7 +78,8 @@ class A:
 [builtins fixtures/dict.pyi]
 
 [case testBytesLiteral]
-b, a = None, None # type: (bytes, A)
+b: bytes
+a: A
 if str():
     b = b'foo'
 if str():
@@ -90,10 +92,10 @@ class A: pass
 [builtins fixtures/dict.pyi]
 
 [case testUnicodeLiteralInPython3]
-s = None  # type: str
+s: str
 if int():
     s = u'foo'
-b = None  # type: bytes
+b: bytes
 if int():
     b = u'foo' # E: Incompatible types in assignment (expression has type "str", variable has type "bytes")
 [builtins fixtures/primitives.pyi]
@@ -104,7 +106,9 @@ if int():
 
 
 [case testAdd]
-a, b, c = None, None, None # type: (A, B, C)
+a: A
+b: B
+c: C
 if int():
     c = a + c  # E: Unsupported operand types for + ("A" and "C")
 if int():
@@ -124,7 +128,9 @@ class C:
 [builtins fixtures/tuple.pyi]
 
 [case testSub]
-a, b, c = None, None, None # type: (A, B, C)
+a: A
+b: B
+c: C
 if int():
     c = a - c  # E: Unsupported operand types for - ("A" and "C")
 if int():
@@ -144,7 +150,9 @@ class C:
 [builtins fixtures/tuple.pyi]
 
 [case testMul]
-a, b, c = None, None, None # type: (A, B, C)
+a: A
+b: B
+c: C
 if int():
     c = a * c  # E: Unsupported operand types for * ("A" and "C")
 if int():
@@ -164,7 +172,9 @@ class C:
 [builtins fixtures/tuple.pyi]
 
 [case testMatMul]
-a, b, c = None, None, None # type: (A, B, C)
+a: A
+b: B
+c: C
 if int():
     c = a @ c  # E: Unsupported operand types for @ ("A" and "C")
 if int():
@@ -184,7 +194,9 @@ class C:
 [builtins fixtures/tuple.pyi]
 
 [case testDiv]
-a, b, c = None, None, None # type: (A, B, C)
+a: A
+b: B
+c: C
 if int():
     c = a / c  # E: Unsupported operand types for / ("A" and "C")
     a = a / b  # E: Incompatible types in assignment (expression has type "C", variable has type "A")
@@ -203,7 +215,9 @@ class C:
 [builtins fixtures/tuple.pyi]
 
 [case testIntDiv]
-a, b, c = None, None, None # type: (A, B, C)
+a: A
+b: B
+c: C
 if int():
     c = a // c  # E: Unsupported operand types for // ("A" and "C")
     a = a // b  # E: Incompatible types in assignment (expression has type "C", variable has type "A")
@@ -222,7 +236,9 @@ class C:
 [builtins fixtures/tuple.pyi]
 
 [case testMod]
-a, b, c = None, None, None # type: (A, B, C)
+a: A
+b: B
+c: C
 if int():
     c = a % c  # E: Unsupported operand types for % ("A" and "C")
 if int():
@@ -242,7 +258,9 @@ class C:
 [builtins fixtures/tuple.pyi]
 
 [case testPow]
-a, b, c = None, None, None # type: (A, B, C)
+a: A
+b: B
+c: C
 if int():
     c = a ** c  # E: Unsupported operand types for ** ("A" and "C")
 if int():
@@ -262,8 +280,8 @@ class C:
 [builtins fixtures/tuple.pyi]
 
 [case testMiscBinaryOperators]
-
-a, b = None, None # type: (A, B)
+a: A
+b: B
 b = a & a  # Fail
 b = a | b  # Fail
 b = a ^ a  # Fail
@@ -291,7 +309,8 @@ main:6: error: Unsupported operand types for << ("A" and "B")
 main:7: error: Unsupported operand types for >> ("A" and "A")
 
 [case testBooleanAndOr]
-a, b = None, None # type: (A, bool)
+a: A
+b: bool
 if int():
     b = b and b
 if int():
@@ -310,8 +329,8 @@ class A: pass
 
 [case testRestrictedTypeAnd]
 
-b = None # type: bool
-i = None # type: str
+b: bool
+i: str
 j = not b and i
 if j:
     reveal_type(j) # N: Revealed type is "builtins.str"
@@ -319,8 +338,8 @@ if j:
 
 [case testRestrictedTypeOr]
 
-b = None # type: bool
-i = None # type: str
+b: bool
+i: str
 j = b or i
 if not j:
     reveal_type(j) # N: Revealed type is "builtins.str"
@@ -343,7 +362,9 @@ def f(a: List[str], b: bool) -> bool:
 [builtins fixtures/list.pyi]
 
 [case testNonBooleanOr]
-c, d, b = None, None, None # type: (C, D, bool)
+c: C
+d: D
+b: bool
 if int():
     c = c or c
 if int():
@@ -362,7 +383,11 @@ class D(C): pass
 
 [case testInOperator]
 from typing import Iterator, Iterable, Any
-a, b, c, d, e = None, None, None, None, None # type: (A, B, bool, D, Any)
+a: A
+b: B
+c: bool
+d: D
+e: Any
 if int():
     c = c in a  # E: Unsupported operand types for in ("bool" and "A")
 if int():
@@ -389,7 +414,11 @@ class D(Iterable[A]):
 
 [case testNotInOperator]
 from typing import Iterator, Iterable, Any
-a, b, c, d, e = None, None, None, None, None # type: (A, B, bool, D, Any)
+a: A
+b: B
+c: bool
+d: D
+e: Any
 if int():
     c = c not in a  # E: Unsupported operand types for in ("bool" and "A")
 if int():
@@ -415,7 +444,9 @@ class D(Iterable[A]):
 [builtins fixtures/bool.pyi]
 
 [case testNonBooleanContainsReturnValue]
-a, b, c = None, None, None # type: (A, bool, str)
+a: A
+b: bool
+c: str
 if int():
     b = a not in a
 if int():
@@ -434,8 +465,8 @@ a = 1 in ([1] + ['x'])  # E: List item 0 has incompatible type "str"; expected "
 [builtins fixtures/list.pyi]
 
 [case testEq]
-
-a, b = None, None # type: (A, bool)
+a: A
+b: bool
 if int():
     a = a == b # E: Incompatible types in assignment (expression has type "bool", variable has type "A")
 if int():
@@ -451,7 +482,9 @@ class A:
 [builtins fixtures/bool.pyi]
 
 [case testLtAndGt]
-a, b, bo = None, None, None # type: (A, B, bool)
+a: A
+b: B
+bo: bool
 if int():
     a = a < b # E: Incompatible types in assignment (expression has type "bool", variable has type "A")
 if int():
@@ -470,7 +503,9 @@ class B:
 [builtins fixtures/bool.pyi]
 
 [case cmpIgnoredPy3]
-a, b, bo = None, None, None # type: (A, B, bool)
+a: A
+b: B
+bo: bool
 bo = a <= b # E: Unsupported left operand type for <= ("A")
 
 class A:
@@ -480,7 +515,9 @@ class B:
 [builtins fixtures/bool.pyi]
 
 [case testLeAndGe]
-a, b, bo = None, None, None # type: (A, B, bool)
+a: A
+b: B
+bo: bool
 if int():
     a = a <= b # E: Incompatible types in assignment (expression has type "bool", variable has type "A")
 if int():
@@ -499,8 +536,9 @@ class B:
 [builtins fixtures/bool.pyi]
 
 [case testChainedComp]
-
-a, b, bo = None, None, None # type: (A, B, bool)
+a: A
+b: B
+bo: bool
 a < a < b < b # Fail
 a < b < b < b
 a < a > a < b # Fail
@@ -513,13 +551,15 @@ class B:
     def __gt__(self, o: 'B') -> bool: pass
 [builtins fixtures/bool.pyi]
 [out]
-main:3: error: Unsupported operand types for < ("A" and "A")
-main:5: error: Unsupported operand types for < ("A" and "A")
-main:5: error: Unsupported operand types for > ("A" and "A")
+main:4: error: Unsupported operand types for < ("A" and "A")
+main:6: error: Unsupported operand types for < ("A" and "A")
+main:6: error: Unsupported operand types for > ("A" and "A")
 
 
 [case testChainedCompBoolRes]
-a, b, bo = None, None, None # type: (A, B, bool)
+a: A
+b: B
+bo: bool
 if int():
     bo = a < b < b
 if int():
@@ -535,8 +575,12 @@ class B:
 
 
 [case testChainedCompResTyp]
-x, y = None, None # type: (X, Y)
-a, b, p, bo = None, None, None, None # type: (A, B, P, bool)
+x: X
+y: Y
+a: A
+b: B
+p: P
+bo: bool
 if int():
     b = y == y == y
 if int():
@@ -566,7 +610,8 @@ class Y:
 
 
 [case testIs]
-a, b = None, None # type: (A, bool)
+a: A
+b: bool
 if int():
     a = a is b # E: Incompatible types in assignment (expression has type "bool", variable has type "A")
 if int():
@@ -579,7 +624,8 @@ class A: pass
 [builtins fixtures/bool.pyi]
 
 [case testIsNot]
-a, b = None, None # type: (A, bool)
+a: A
+b: bool
 if int():
     a = a is not b # E: Incompatible types in assignment (expression has type "bool", variable has type "A")
 if int():
@@ -604,8 +650,8 @@ class A:
     def __add__(self, x: int) -> int: pass
 class B:
     def __radd__(self, x: A) -> str: pass
-s = None  # type: str
-n = None  # type: int
+s: str
+n: int
 if int():
     n = A() + 1
 if int():
@@ -618,8 +664,8 @@ class A:
     def __add__(self, x: 'A') -> object: pass
 class B:
     def __radd__(self, x: A) -> str: pass
-s = None  # type: str
-n = None  # type: int
+s: str
+n: int
 if int():
     s = A() + B()
     n = A() + B() # E: Incompatible types in assignment (expression has type "str", variable has type "int")
@@ -632,7 +678,7 @@ class A:
     def __add__(self, x: N) -> int: pass
 class B:
     def __radd__(self, x: N) -> str: pass
-s = None  # type: str
+s: str
 s = A() + B() # E: Unsupported operand types for + ("A" and "B")
 
 [case testBinaryOperatorWithAnyRightOperand]
@@ -647,8 +693,8 @@ class A:
     def __lt__(self, x: C) -> int: pass  # E: Signatures of "__lt__" of "A" and "__gt__" of "C" are unsafely overlapping
 class B:
     def __gt__(self, x: A) -> str: pass
-s = None  # type: str
-n = None  # type: int
+s: str
+n: int
 if int():
     n = A() < C()
     s = A() < B()
@@ -743,8 +789,8 @@ divmod('foo', d)  # E: Unsupported operand types for divmod ("str" and "Decimal"
 
 
 [case testUnaryMinus]
-
-a, b = None, None # type: (A, B)
+a: A
+b: B
 if int():
     a = -a   # E: Incompatible types in assignment (expression has type "B", variable has type "A")
 if int():
@@ -760,7 +806,8 @@ class B:
 [builtins fixtures/tuple.pyi]
 
 [case testUnaryPlus]
-a, b = None, None # type: (A, B)
+a: A
+b: B
 if int():
     a = +a   # E: Incompatible types in assignment (expression has type "B", variable has type "A")
 if int():
@@ -776,7 +823,8 @@ class B:
 [builtins fixtures/tuple.pyi]
 
 [case testUnaryNot]
-a, b = None, None # type: (A, bool)
+a: A
+b: bool
 if int():
     a = not b  # E: Incompatible types in assignment (expression has type "bool", variable has type "A")
 if int():
@@ -788,7 +836,8 @@ class A:
 [builtins fixtures/bool.pyi]
 
 [case testUnaryBitwiseNeg]
-a, b = None, None # type: (A, B)
+a: A
+b: B
 if int():
     a = ~a   # E: Incompatible types in assignment (expression has type "B", variable has type "A")
 if int():
@@ -809,8 +858,9 @@ class B:
 
 
 [case testIndexing]
-
-a, b, c = None, None, None # type: (A, B, C)
+a: A
+b: B
+c: C
 if int():
     c = a[c]  # E: Invalid index type "C" for "A"; expected type "B"
 if int():
@@ -828,8 +878,9 @@ class C: pass
 [builtins fixtures/tuple.pyi]
 
 [case testIndexingAsLvalue]
-
-a, b, c = None, None, None # type: (A, B, C)
+a: A
+b: B
+c: C
 a[c] = c  # Fail
 a[b] = a  # Fail
 b[a] = c  # Fail
@@ -844,16 +895,17 @@ class C:
     pass
 [builtins fixtures/tuple.pyi]
 [out]
-main:3: error: Invalid index type "C" for "A"; expected type "B"
-main:4: error: Incompatible types in assignment (expression has type "A", target has type "C")
-main:5: error: Unsupported target for indexed assignment ("B")
+main:4: error: Invalid index type "C" for "A"; expected type "B"
+main:5: error: Incompatible types in assignment (expression has type "A", target has type "C")
+main:6: error: Unsupported target for indexed assignment ("B")
 
 [case testOverloadedIndexing]
 from foo import *
 [file foo.pyi]
 from typing import overload
-
-a, b, c = None, None, None  # type: (A, B, C)
+a: A
+b: B
+c: C
 a[b]
 a[c]
 a[1]  # E: No overload variant of "__getitem__" of "A" matches argument type "int" \
@@ -861,7 +913,8 @@ a[1]  # E: No overload variant of "__getitem__" of "A" matches argument type "in
       # N:     def __getitem__(self, B, /) -> int \
       # N:     def __getitem__(self, C, /) -> str
 
-i, s = None, None  # type: (int, str)
+i: int
+s: str
 if int():
     i = a[b]
 if int():
@@ -893,7 +946,9 @@ from typing import cast, Any
 class A: pass
 class B: pass
 class C(A): pass
-a, b, c = None, None, None # type: (A, B, C)
+a: A
+b: B
+c: C
 
 if int():
     a = cast(A, a())       # E: "A" not callable
@@ -916,7 +971,8 @@ if int():
 
 [case testAnyCast]
 from typing import cast, Any
-a, b = None, None # type: (A, B)
+a: A
+b: B
 a = cast(Any, a())     # Fail
 a = cast(Any, b)
 b = cast(Any, a)
@@ -924,7 +980,7 @@ class A: pass
 class B: pass
 [builtins fixtures/tuple.pyi]
 [out]
-main:3: error: "A" not callable
+main:4: error: "A" not callable
 
 -- assert_type()
 
@@ -1003,7 +1059,8 @@ class A:
     def __call__(self) -> None:
         pass
 
-a, o = None, None # type: (A, object)
+a: A
+o: object
 if int():
     a = f()         # E: "f" does not return a value
 if int():
@@ -1040,7 +1097,7 @@ def f() -> None: pass
 class A:
     def __add__(self, x: 'A') -> 'A': pass
 
-a = None # type: A
+a: A
 [f()]       # E: "f" does not return a value
 f() + a     # E: "f" does not return a value
 a + f()     # E: "f" does not return a value
@@ -1058,7 +1115,8 @@ class A:
     def __add__(self, x: 'A') -> 'A':
         pass
 
-a, b = None, None # type: (A, bool)
+a: A
+b: bool
 f() in a   # E: "f" does not return a value  # E: Unsupported right operand type for in ("A")
 a < f()    # E: "f" does not return a value
 f() <= a   # E: "f" does not return a value
@@ -1075,7 +1133,8 @@ b or f()   # E: "f" does not return a value
 
 
 [case testGetSlice]
-a, b = None, None # type: (A, B)
+a: A
+b: B
 if int():
     a = a[1:2] # E: Incompatible types in assignment (expression has type "B", variable has type "A")
 if int():
@@ -1101,7 +1160,7 @@ class B: pass
 
 [case testSlicingWithInvalidBase]
 
-a = None # type: A
+a: A
 a[1:2] # E: Invalid index type "slice" for "A"; expected type "int"
 a[:]   # E: Invalid index type "slice" for "A"; expected type "int"
 class A:
@@ -1110,7 +1169,7 @@ class A:
 
 [case testSlicingWithNonindexable]
 
-o = None # type: object
+o: object
 o[1:2] # E: Value of type "object" is not indexable
 o[:]   # E: Value of type "object" is not indexable
 [builtins fixtures/slice.pyi]
@@ -1143,7 +1202,7 @@ class SupportsIndex(Protocol):
 
 [case testNoneSliceBounds]
 from typing import Any
-a = None # type: Any
+a: Any
 a[None:1]
 a[1:None]
 a[None:]
@@ -1153,7 +1212,7 @@ a[:None]
 [case testNoneSliceBoundsWithStrictOptional]
 # flags: --strict-optional
 from typing import Any
-a = None # type: Any
+a: Any
 a[None:1]
 a[1:None]
 a[None:]
@@ -1182,6 +1241,7 @@ def void() -> None:
 x = lambda: void() # type: typing.Callable[[], None]
 
 [case testNoCrashOnLambdaGenerator]
+# flags: --no-strict-optional
 from typing import Iterator, Callable
 
 # These should not crash
@@ -1211,7 +1271,7 @@ def f() -> None:
 
 [case testSimpleListComprehension]
 from typing import List
-a = None # type: List[A]
+a: List[A]
 a = [x for x in a]
 b = [x for x in a] # type: List[B] # E: List comprehension has incompatible type List[A]; expected List[B]
 class A: pass
@@ -1220,7 +1280,7 @@ class B: pass
 
 [case testSimpleListComprehensionNestedTuples]
 from typing import List, Tuple
-l = None # type: List[Tuple[A, Tuple[A, B]]]
+l: List[Tuple[A, Tuple[A, B]]]
 a = [a2 for a1, (a2, b1) in l] # type: List[A]
 b = [a2 for a1, (a2, b1) in l] # type: List[B] # E: List comprehension has incompatible type List[A]; expected List[B]
 class A: pass
@@ -1229,7 +1289,7 @@ class B: pass
 
 [case testSimpleListComprehensionNestedTuples2]
 from typing import List, Tuple
-l = None # type: List[Tuple[int, Tuple[int, str]]]
+l: List[Tuple[int, Tuple[int, str]]]
 a = [f(d) for d, (i, s) in l]
 b = [f(s) for d, (i, s) in l] # E: Argument 1 to "f" has incompatible type "str"; expected "int"
 
@@ -1252,14 +1312,14 @@ def f(a: A) -> B: pass
 
 [case testErrorInListComprehensionCondition]
 from typing import List
-a = None # type: List[A]
+a: List[A]
 a = [x for x in a if x()] # E: "A" not callable
 class A: pass
 [builtins fixtures/for.pyi]
 
 [case testTypeInferenceOfListComprehension]
 from typing import List
-a = None # type: List[A]
+a: List[A]
 o = [x for x in a] # type: List[object]
 class A: pass
 [builtins fixtures/for.pyi]
@@ -1267,7 +1327,7 @@ class A: pass
 [case testSimpleListComprehensionInClassBody]
 from typing import List
 class A:
-    a = None # type: List[A]
+    a: List[A]
     a = [x for x in a]
     b = [x for x in a] # type: List[B] # E: List comprehension has incompatible type List[A]; expected List[B]
 class B: pass
@@ -1281,7 +1341,7 @@ class B: pass
 
 [case testSimpleSetComprehension]
 from typing import Set
-a = None # type: Set[A]
+a: Set[A]
 a = {x for x in a}
 b = {x for x in a} # type: Set[B] # E: Set comprehension has incompatible type Set[A]; expected Set[B]
 class A: pass
@@ -1295,8 +1355,8 @@ class B: pass
 
 [case testSimpleDictionaryComprehension]
 from typing import Dict, List, Tuple
-abd = None # type: Dict[A, B]
-abl = None # type: List[Tuple[A, B]]
+abd: Dict[A, B]
+abl: List[Tuple[A, B]]
 abd = {a: b for a, b in abl}
 x = {a: b for a, b in abl} # type: Dict[B, A]
 y = {a: b for a, b in abl} # type: A
@@ -1312,7 +1372,7 @@ main:6: error: Incompatible types in assignment (expression has type "Dict[A, B]
 [case testDictionaryComprehensionWithNonDirectMapping]
 from typing import Dict, List, Tuple
 abd: Dict[A, B]
-abl = None # type: List[Tuple[A, B]]
+abl: List[Tuple[A, B]]
 abd = {a: f(b) for a, b in abl}
 class A: pass
 class B: pass
@@ -1332,10 +1392,10 @@ main:4: error: Argument 1 to "f" has incompatible type "B"; expected "A"
 from typing import Iterator
 # The implementation is mostly identical to list comprehensions, so only a few
 # test cases is ok.
-a = None # type: Iterator[int]
+a: Iterator[int]
 if int():
     a = (x for x in a)
-b = None # type: Iterator[str]
+b: Iterator[str]
 if int():
     b = (x for x in a) # E: Generator has incompatible item type "int"; expected "str"
 [builtins fixtures/for.pyi]
@@ -1344,7 +1404,7 @@ if int():
 from typing import Callable, Iterator, List
 
 a = []  # type: List[Callable[[], str]]
-b = None  # type: Iterator[Callable[[], int]]
+b: Iterator[Callable[[], int]]
 if int():
     b = (x for x in a)  # E: Generator has incompatible item type "Callable[[], str]"; expected "Callable[[], int]"
 [builtins fixtures/list.pyi]
@@ -1441,14 +1501,14 @@ class A:
     def __add__(self, a: 'A') -> 'A': pass
 def f() -> None:
     pass
-a = None # type: A
+a: A
 None + a   # E: Unsupported left operand type for + ("None")
 f + a      # E: Unsupported left operand type for + ("Callable[[], None]")
 a + f      # E: Unsupported operand types for + ("A" and "Callable[[], None]")
 cast(A, f)
 [case testOperatorMethodWithInvalidArgCount]
 
-a = None # type: A
+a: A
 a + a  # Fail
 
 class A:
@@ -1462,7 +1522,7 @@ from typing import Any
 class A:
     def __init__(self, _add: Any) -> None:
         self.__add__ = _add
-a = None # type: A
+a: A
 a + a
 [out]
 
@@ -1471,15 +1531,16 @@ a + a
 class A:
     def f(self, x: int) -> str: pass
     __add__ = f
-s = None  # type: str
+s: str
 s = A() + 1
 A() + (A() + 1)
 [out]
 main:7: error: Argument 1 has incompatible type "str"; expected "int"
 
 [case testIndexedLvalueWithSubtypes]
-
-a, b, c = None, None, None # type: (A, B, C)
+a: A
+b: B
+c: C
 a[c] = c
 a[b] = c
 a[c] = b
@@ -1501,7 +1562,7 @@ class C(B):
 
 [case testEllipsis]
 
-a = None # type: A
+a: A
 if str():
     a = ...  # E: Incompatible types in assignment (expression has type "ellipsis", variable has type "A")
 b = ...

From e0b159e0bb6bd414d2999bfcecbb5432541ec3fd Mon Sep 17 00:00:00 2001
From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
Date: Thu, 6 Jul 2023 10:07:13 +0200
Subject: [PATCH 121/129] Enable strict optional for more test files (6)
 (#15603)

---
 mypy/test/testcheck.py                      |   3 -
 test-data/unit/check-functions.test         | 109 +++++++-------
 test-data/unit/check-generic-subtyping.test | 135 +++++++++--------
 test-data/unit/check-generics.test          | 154 +++++++++++---------
 4 files changed, 216 insertions(+), 185 deletions(-)

diff --git a/mypy/test/testcheck.py b/mypy/test/testcheck.py
index 47e01910cf2c4..f15e5afabf0e8 100644
--- a/mypy/test/testcheck.py
+++ b/mypy/test/testcheck.py
@@ -51,9 +51,6 @@
 
 # TODO: Enable strict optional in test cases by default. Remove files here, once test cases are updated
 no_strict_optional_files = {
-    "check-functions.test",
-    "check-generic-subtyping.test",
-    "check-generics.test",
     "check-inference-context.test",
     "check-inference.test",
     "check-isinstance.test",
diff --git a/test-data/unit/check-functions.test b/test-data/unit/check-functions.test
index b5d540b105e33..141d18ae26660 100644
--- a/test-data/unit/check-functions.test
+++ b/test-data/unit/check-functions.test
@@ -10,8 +10,9 @@
 
 [case testCallingVariableWithFunctionType]
 from typing import Callable
-f = None # type: Callable[[A], B]
-a, b = None, None # type: (A, B)
+f: Callable[[A], B]
+a: A
+b: B
 if int():
     a = f(a)    # E: Incompatible types in assignment (expression has type "B", variable has type "A")
 if int():
@@ -82,9 +83,9 @@ from typing import Callable
 class A: pass
 class B(A): pass
 
-f = None # type: Callable[[B], A]
-g = None # type: Callable[[A], A]  # subtype of f
-h = None # type: Callable[[B], B]  # subtype of f
+f: Callable[[B], A]
+g: Callable[[A], A]  # subtype of f
+h: Callable[[B], B]  # subtype of f
 if int():
     g = h  # E: Incompatible types in assignment (expression has type "Callable[[B], B]", variable has type "Callable[[A], A]")
 if int():
@@ -132,7 +133,7 @@ ff = g
 from typing import Callable
 
 def f(a: int, b: str) -> None: pass
-f_nonames = None # type: Callable[[int, str], None]
+f_nonames: Callable[[int, str], None]
 def g(a: int, b: str = "") -> None: pass
 def h(aa: int, b: str = "") -> None: pass
 
@@ -160,7 +161,7 @@ if int():
 from typing import Any, Callable
 
 def everything(*args: Any, **kwargs: Any) -> None: pass
-everywhere = None # type: Callable[..., None]
+everywhere: Callable[..., None]
 
 def specific_1(a: int, b: str) -> None: pass
 def specific_2(a: int, *, b: str) -> None: pass
@@ -238,6 +239,7 @@ if int():
     gg = f # E: Incompatible types in assignment (expression has type "Callable[[int, str], None]", variable has type "Callable[[Arg(int, 'a'), Arg(str, 'b')], None]")
 
 [case testFunctionTypeCompatibilityWithOtherTypes]
+# flags: --no-strict-optional
 from typing import Callable
 f = None # type: Callable[[], None]
 a, o = None, None # type: (A, object)
@@ -272,8 +274,8 @@ def g(x: int) -> Tuple[()]:
 
 [case testFunctionSubtypingWithVoid]
 from typing import Callable
-f = None # type: Callable[[], None]
-g = None # type: Callable[[], object]
+f: Callable[[], None]
+g: Callable[[], object]
 if int():
     f = g  # E: Incompatible types in assignment (expression has type "Callable[[], object]", variable has type "Callable[[], None]")
 if int():
@@ -286,9 +288,9 @@ if int():
 
 [case testFunctionSubtypingWithMultipleArgs]
 from typing import Callable
-f = None # type: Callable[[A, A], None]
-g = None # type: Callable[[A, B], None]
-h = None # type: Callable[[B, B], None]
+f: Callable[[A, A], None]
+g: Callable[[A, B], None]
+h: Callable[[B, B], None]
 if int():
     f = g  # E: Incompatible types in assignment (expression has type "Callable[[A, B], None]", variable has type "Callable[[A, A], None]")
 if int():
@@ -313,9 +315,9 @@ class B(A): pass
 
 [case testFunctionTypesWithDifferentArgumentCounts]
 from typing import Callable
-f = None # type: Callable[[], None]
-g = None # type: Callable[[A], None]
-h = None # type: Callable[[A, A], None]
+f: Callable[[], None]
+g: Callable[[A], None]
+h: Callable[[A, A], None]
 
 if int():
     f = g   # E: Incompatible types in assignment (expression has type "Callable[[A], None]", variable has type "Callable[[], None]")
@@ -342,8 +344,8 @@ class A:
 
 def f() -> None: pass
 
-t = None # type: type
-a = None # type: A
+t: type
+a: A
 
 if int():
     a = A # E: Incompatible types in assignment (expression has type "Type[A]", variable has type "A")
@@ -356,9 +358,9 @@ if int():
 from foo import *
 [file foo.pyi]
 from typing import Callable, overload
-f = None # type: Callable[[AA], A]
-g = None # type: Callable[[B], B]
-h = None # type: Callable[[A], AA]
+f: Callable[[AA], A]
+g: Callable[[B], B]
+h: Callable[[A], AA]
 
 if int():
     h = i  # E: Incompatible types in assignment (expression has type overloaded function, variable has type "Callable[[A], AA]")
@@ -395,11 +397,13 @@ def j(x: A) -> AA:
 from foo import *
 [file foo.pyi]
 from typing import Callable, overload
-g1 = None # type: Callable[[A], A]
-g2 = None # type: Callable[[B], B]
-g3 = None # type: Callable[[C], C]
-g4 = None # type: Callable[[A], B]
-a, b, c = None, None, None # type: (A, B, C)
+g1: Callable[[A], A]
+g2: Callable[[B], B]
+g3: Callable[[C], C]
+g4: Callable[[A], B]
+a: A
+b: B
+c: C
 
 if int():
     b = f(a)  # E: Incompatible types in assignment (expression has type "A", variable has type "B")
@@ -448,15 +452,15 @@ f([D])  # E: List item 0 has incompatible type "Type[D]"; expected "Callable[[An
 [case testSubtypingTypeTypeAsCallable]
 from typing import Callable, Type
 class A: pass
-x = None  # type: Callable[..., A]
-y = None  # type: Type[A]
+x: Callable[..., A]
+y: Type[A]
 x = y
 
 [case testSubtypingCallableAsTypeType]
 from typing import Callable, Type
 class A: pass
-x = None  # type: Callable[..., A]
-y = None  # type: Type[A]
+x: Callable[..., A]
+y: Type[A]
 if int():
     y = x  # E: Incompatible types in assignment (expression has type "Callable[..., A]", variable has type "Type[A]")
 
@@ -573,11 +577,11 @@ A().f('') # E: Argument 1 to "f" of "A" has incompatible type "str"; expected "i
 [case testMethodAsDataAttribute]
 from typing import Any, Callable, ClassVar
 class B: pass
-x = None # type: Any
+x: Any
 class A:
     f = x # type: ClassVar[Callable[[A], None]]
     g = x # type: ClassVar[Callable[[A, B], None]]
-a = None # type: A
+a: A
 a.f()
 a.g(B())
 a.f(a) # E: Too many arguments
@@ -586,21 +590,21 @@ a.g()  # E: Too few arguments
 [case testMethodWithInvalidMethodAsDataAttribute]
 from typing import Any, Callable, ClassVar
 class B: pass
-x = None # type: Any
+x: Any
 class A:
     f = x # type: ClassVar[Callable[[], None]]
     g = x # type: ClassVar[Callable[[B], None]]
-a = None # type: A
+a: A
 a.f() # E: Attribute function "f" with type "Callable[[], None]" does not accept self argument
 a.g() # E: Invalid self argument "A" to attribute function "g" with type "Callable[[B], None]"
 
 [case testMethodWithDynamicallyTypedMethodAsDataAttribute]
 from typing import Any, Callable, ClassVar
 class B: pass
-x = None # type: Any
+x: Any
 class A:
     f = x # type: ClassVar[Callable[[Any], Any]]
-a = None # type: A
+a: A
 a.f()
 a.f(a) # E: Too many arguments
 
@@ -627,7 +631,7 @@ class A:
     @overload
     def f(self, b: B) -> None: pass
     g = f
-a = None # type: A
+a: A
 a.g()
 a.g(B())
 a.g(a) # E: No overload variant matches argument type "A" \
@@ -640,7 +644,7 @@ a.g(a) # E: No overload variant matches argument type "A" \
 class A:
     def f(self, x): pass
     g = f
-a = None # type: A
+a: A
 a.g(object())
 a.g(a, a) # E: Too many arguments
 a.g()     # E: Too few arguments
@@ -652,7 +656,7 @@ class B: pass
 class A(Generic[t]):
     def f(self, x: t) -> None: pass
     g = f
-a = None # type: A[B]
+a: A[B]
 a.g(B())
 a.g(a)   # E: Argument 1 has incompatible type "A[B]"; expected "B"
 
@@ -661,11 +665,11 @@ from typing import Any, TypeVar, Generic, Callable, ClassVar
 t = TypeVar('t')
 class B: pass
 class C: pass
-x = None # type: Any
+x: Any
 class A(Generic[t]):
     f = x # type: ClassVar[Callable[[A[B]], None]]
-ab = None # type: A[B]
-ac = None # type: A[C]
+ab: A[B]
+ac: A[C]
 ab.f()
 ac.f()   # E: Invalid self argument "A[C]" to attribute function "f" with type "Callable[[A[B]], None]"
 
@@ -674,21 +678,21 @@ from typing import Any, TypeVar, Generic, Callable, ClassVar
 t = TypeVar('t')
 class B: pass
 class C: pass
-x = None # type: Any
+x: Any
 class A(Generic[t]):
     f = x # type: ClassVar[Callable[[A], None]]
-ab = None # type: A[B]
-ac = None # type: A[C]
+ab: A[B]
+ac: A[C]
 ab.f()
 ac.f()
 
 [case testCallableDataAttribute]
 from typing import Callable, ClassVar
 class A:
-    g = None # type: ClassVar[Callable[[A], None]]
+    g: ClassVar[Callable[[A], None]]
     def __init__(self, f: Callable[[], None]) -> None:
         self.f = f
-a = A(None)
+a = A(lambda: None)
 a.f()
 a.g()
 a.f(a) # E: Too many arguments
@@ -895,7 +899,7 @@ def dec(x) -> Callable[[Any], None]: pass
 class A:
     @dec
     def f(self, a, b, c): pass
-a = None # type: A
+a: A
 a.f()
 a.f(None) # E: Too many arguments for "f" of "A"
 
@@ -1945,9 +1949,9 @@ def a(f: Callable[[VarArg(int)], int]):
 from typing import Callable
 from mypy_extensions import Arg, DefaultArg
 
-int_str_fun = None # type: Callable[[int, str], str]
-int_opt_str_fun = None # type: Callable[[int, DefaultArg(str, None)], str]
-int_named_str_fun = None # type: Callable[[int, Arg(str, 's')], str]
+int_str_fun: Callable[[int, str], str]
+int_opt_str_fun: Callable[[int, DefaultArg(str, None)], str]
+int_named_str_fun: Callable[[int, Arg(str, 's')], str]
 
 def isf(ii: int, ss: str) -> str:
     return ss
@@ -2140,6 +2144,7 @@ main:8: error: Cannot use a covariant type variable as a parameter
 from typing import TypeVar, Generic, Callable
 
 [case testRejectContravariantReturnType]
+# flags: --no-strict-optional
 from typing import TypeVar, Generic
 
 t = TypeVar('t', contravariant=True)
@@ -2148,9 +2153,10 @@ class A(Generic[t]):
         return None
 [builtins fixtures/bool.pyi]
 [out]
-main:5: error: Cannot use a contravariant type variable as return type
+main:6: error: Cannot use a contravariant type variable as return type
 
 [case testAcceptCovariantReturnType]
+# flags: --no-strict-optional
 from typing import TypeVar, Generic
 
 t = TypeVar('t', covariant=True)
@@ -2158,6 +2164,7 @@ class A(Generic[t]):
     def foo(self) -> t:
         return None
 [builtins fixtures/bool.pyi]
+
 [case testAcceptContravariantArgument]
 from typing import TypeVar, Generic
 
diff --git a/test-data/unit/check-generic-subtyping.test b/test-data/unit/check-generic-subtyping.test
index a34e054fd827a..11c92d07021a2 100644
--- a/test-data/unit/check-generic-subtyping.test
+++ b/test-data/unit/check-generic-subtyping.test
@@ -9,9 +9,9 @@
 [case testSubtypingAndInheritingNonGenericTypeFromGenericType]
 from typing import TypeVar, Generic
 T = TypeVar('T')
-ac = None # type: A[C]
-ad = None # type: A[D]
-b = None # type: B
+ac: A[C]
+ad: A[D]
+b: B
 
 if int():
     b = ad # E: Incompatible types in assignment (expression has type "A[D]", variable has type "B")
@@ -31,9 +31,9 @@ class D: pass
 [case testSubtypingAndInheritingGenericTypeFromNonGenericType]
 from typing import TypeVar, Generic
 T = TypeVar('T')
-a = None # type: A
-bc = None # type: B[C]
-bd = None # type: B[D]
+a: A
+bc: B[C]
+bd: B[D]
 
 if int():
     bc = bd # E: Incompatible types in assignment (expression has type "B[D]", variable has type "B[C]")
@@ -56,10 +56,10 @@ class D: pass
 from typing import TypeVar, Generic
 T = TypeVar('T')
 S = TypeVar('S')
-ac = None # type: A[C]
-ad = None # type: A[D]
-bcc = None # type: B[C, C]
-bdc = None # type: B[D, C]
+ac: A[C]
+ad: A[D]
+bcc: B[C, C]
+bdc: B[D, C]
 
 if int():
     ad = bcc # E: Incompatible types in assignment (expression has type "B[C, C]", variable has type "A[D]")
@@ -86,12 +86,12 @@ T = TypeVar('T')
 S = TypeVar('S')
 X = TypeVar('X')
 Y = TypeVar('Y')
-ae = None # type: A[A[E]]
-af = None # type: A[A[F]]
+ae: A[A[E]]
+af: A[A[F]]
 
-cef = None # type: C[E, F]
-cff = None # type: C[F, F]
-cfe = None # type: C[F, E]
+cef: C[E, F]
+cff: C[F, F]
+cfe: C[F, E]
 
 if int():
     ae = cef # E: Incompatible types in assignment (expression has type "C[E, F]", variable has type "A[A[E]]")
@@ -125,8 +125,9 @@ class C: pass
 from typing import TypeVar, Generic
 T = TypeVar('T')
 S = TypeVar('S')
-b = None # type: B[C, D]
-c, d = None, None # type: (C, D)
+b: B[C, D]
+c: C
+d: D
 
 b.f(c) # E: Argument 1 to "f" of "A" has incompatible type "C"; expected "D"
 b.f(d)
@@ -142,7 +143,9 @@ class D: pass
 [case testAccessingMethodInheritedFromGenericTypeInNonGenericType]
 from typing import TypeVar, Generic
 T = TypeVar('T')
-b, c, d = None, None, None # type: (B, C, D)
+b: B
+c: C
+d: D
 
 b.f(c) # E: Argument 1 to "f" of "A" has incompatible type "C"; expected "D"
 b.f(d)
@@ -163,8 +166,9 @@ class A(Generic[T]):
     def __init__(self, a: T) -> None:
         self.a = a
 
-b = None # type: B[C, D]
-c, d = None, None # type: (C, D)
+b: B[C, D]
+c: C
+d: D
 
 b.a = c # E: Incompatible types in assignment (expression has type "C", variable has type "D")
 b.a = d
@@ -311,9 +315,9 @@ main:14: note:          def [T1 <: str, S] f(self, x: T1, y: S) -> None
 [case testInheritanceFromGenericWithImplicitDynamicAndSubtyping]
 from typing import TypeVar, Generic
 T = TypeVar('T')
-a = None # type: A
-bc = None # type: B[C]
-bd = None # type: B[D]
+a: A
+bc: B[C]
+bd: B[D]
 
 if int():
     a = bc # E: Incompatible types in assignment (expression has type "B[C]", variable has type "A")
@@ -337,9 +341,9 @@ class B(Generic[T]):
 class A(B): pass
 class C: pass
 
-a = None # type: A
-c = None # type: C
-bc = None # type: B[C]
+a: A
+c: C
+bc: B[C]
 
 a.x = c # E: Incompatible types in assignment (expression has type "C", variable has type "B[Any]")
 a.f(c)  # E: Argument 1 to "f" of "B" has incompatible type "C"; expected "B[Any]"
@@ -350,9 +354,9 @@ a.f(bc)
 [case testInheritanceFromGenericWithImplicitDynamic]
 from typing import TypeVar, Generic
 T = TypeVar('T')
-a = None # type: A
-c = None # type: C
-bc = None # type: B[C]
+a: A
+c: C
+bc: B[C]
 
 class B(Generic[T]):
   def f(self, a: 'B[T]') -> None: pass
@@ -458,10 +462,10 @@ from typing import TypeVar, Generic
 from abc import abstractmethod
 T = TypeVar('T')
 S = TypeVar('S')
-acd = None # type: A[C, D]
-adc = None # type: A[D, C]
-ic = None # type: I[C]
-id = None # type: I[D]
+acd: A[C, D]
+adc: A[D, C]
+ic: I[C]
+id: I[D]
 
 if int():
     ic = acd # E: Incompatible types in assignment (expression has type "A[C, D]", variable has type "I[C]")
@@ -482,8 +486,11 @@ class D: pass
 [case testSubtypingWithTypeImplementingGenericABCViaInheritance]
 from typing import TypeVar, Generic
 S = TypeVar('S')
-a, b = None, None # type: (A, B)
-ic, id, ie = None, None, None # type: (I[C], I[D], I[E])
+a: A
+b: B
+ic: I[C]
+id: I[D]
+ie: I[E]
 
 class I(Generic[S]): pass
 class B(I[C]): pass
@@ -523,7 +530,9 @@ main:5: error: Class "B" has base "I" duplicated inconsistently
 from typing import TypeVar, Generic
 from abc import abstractmethod, ABCMeta
 t = TypeVar('t')
-a, i, j = None, None, None # type: (A[object], I[object], J[object])
+a: A[object]
+i: I[object]
+j: J[object]
 (ii, jj) = (i, j)
 if int():
     ii = a
@@ -573,8 +582,9 @@ class D: pass
 from typing import Any, TypeVar, Generic
 from abc import abstractmethod
 T = TypeVar('T')
-a = None # type: A
-ic, id = None, None # type: (I[C], I[D])
+a: A
+ic: I[C]
+id: I[D]
 
 if int():
     id = a # E: Incompatible types in assignment (expression has type "A", variable has type "I[D]")
@@ -625,9 +635,9 @@ class D: pass
 from typing import Any, TypeVar, Generic
 from abc import abstractmethod
 T = TypeVar('T')
-a = None # type: Any
-ic = None # type: I[C]
-id = None # type: I[D]
+a: Any
+ic: I[C]
+id: I[D]
 
 ic = a
 id = a
@@ -645,9 +655,9 @@ class D: pass
 from typing import Any, TypeVar, Generic
 from abc import abstractmethod
 T = TypeVar('T')
-a = None # type: Any
-ic = None # type: I[C]
-id = None # type: I[D]
+a: Any
+ic: I[C]
+id: I[D]
 
 ic = a
 id = a
@@ -666,9 +676,9 @@ class D: pass
 from typing import Any, TypeVar, Generic
 from abc import abstractmethod
 T = TypeVar('T')
-a = None # type: Any
-jc = None # type: J[C]
-jd = None # type: J[D]
+a: Any
+jc: J[C]
+jd: J[D]
 
 jc = a
 jd = a
@@ -700,8 +710,9 @@ class I(Generic[T]):
 class A: pass
 class B: pass
 
-a, b = None, None # type: (A, B)
-ia = None # type: I[A]
+a: A
+b: B
+ia: I[A]
 
 ia.f(b)  # E: Argument 1 to "f" of "I" has incompatible type "B"; expected "A"
 ia.f(a)
@@ -717,8 +728,9 @@ class J(Generic[T]):
 class I(J[T], Generic[T]): pass
 class A: pass
 class B: pass
-a, b = None, None # type: (A, B)
-ia = None # type: I[A]
+a: A
+b: B
+ia: I[A]
 
 ia.f(b)  # E: Argument 1 to "f" of "J" has incompatible type "B"; expected "A"
 ia.f(a)
@@ -731,7 +743,8 @@ ia.f(a)
 
 [case testMultipleAssignmentAndGenericSubtyping]
 from typing import Iterable
-n, s = None, None # type: int, str
+n: int
+s: str
 class Nums(Iterable[int]):
     def __iter__(self): pass
     def __next__(self): pass
@@ -754,9 +767,9 @@ class A: pass
 class B(A): pass
 class C(B): pass
 
-a = None  # type: G[A]
-b = None  # type: G[B]
-c = None  # type: G[C]
+a: G[A]
+b: G[B]
+c: G[C]
 
 if int():
     b = a  # E: Incompatible types in assignment (expression has type "G[A]", variable has type "G[B]")
@@ -773,9 +786,9 @@ class A: pass
 class B(A): pass
 class C(B): pass
 
-a = None  # type: G[A]
-b = None  # type: G[B]
-c = None  # type: G[C]
+a: G[A]
+b: G[B]
+c: G[C]
 
 if int():
     b = a
@@ -792,9 +805,9 @@ class A: pass
 class B(A): pass
 class C(B): pass
 
-a = None  # type: G[A]
-b = None  # type: G[B]
-c = None  # type: G[C]
+a: G[A]
+b: G[B]
+c: G[C]
 
 if int():
     b = a  # E: Incompatible types in assignment (expression has type "G[A]", variable has type "G[B]")
diff --git a/test-data/unit/check-generics.test b/test-data/unit/check-generics.test
index b78fd21d48175..42e3d23eddb9a 100644
--- a/test-data/unit/check-generics.test
+++ b/test-data/unit/check-generics.test
@@ -5,7 +5,9 @@
 [case testGenericMethodReturnType]
 from typing import TypeVar, Generic
 T = TypeVar('T')
-a, b, c = None, None, None # type: (A[B], B, C)
+a: A[B]
+b: B
+c: C
 if int():
     c = a.f() # E: Incompatible types in assignment (expression has type "B", variable has type "C")
     b = a.f()
@@ -24,9 +26,9 @@ T = TypeVar('T')
 class A(Generic[T]):
     def f(self, a: T) -> None: pass
 
-a = None # type: A[B]
-b = None # type: B
-c = None # type: C
+a: A[B]
+b: B
+c: C
 
 a.f(c) # E: Argument 1 to "f" of "A" has incompatible type "C"; expected "B"
 a.f(b)
@@ -40,7 +42,9 @@ class A(Generic[T]):
     def __init__(self, v: T) -> None:
         self.v = v
 
-a, b, c = None, None, None # type: (A[B], B, C)
+a: A[B]
+b: B
+c: C
 a.v = c # Fail
 a.v = b
 
@@ -48,27 +52,31 @@ class B: pass
 class C: pass
 [builtins fixtures/tuple.pyi]
 [out]
-main:8: error: Incompatible types in assignment (expression has type "C", variable has type "B")
+main:10: error: Incompatible types in assignment (expression has type "C", variable has type "B")
 
 [case testGenericMemberVariable2]
 from typing import TypeVar, Generic
 T = TypeVar('T')
-a, b, c = None, None, None # type: (A[B], B, C)
+a: A[B]
+b: B
+c: C
 a.v = c # Fail
 a.v = b
 
 class A(Generic[T]):
-    v = None # type: T
+    v: T
 class B: pass
 class C: pass
 [builtins fixtures/tuple.pyi]
 [out]
-main:4: error: Incompatible types in assignment (expression has type "C", variable has type "B")
+main:6: error: Incompatible types in assignment (expression has type "C", variable has type "B")
 
 [case testSimpleGenericSubtyping]
 from typing import TypeVar, Generic
 T = TypeVar('T')
-b, bb, c = None, None, None # type: (A[B], A[B], A[C])
+b: A[B]
+bb: A[B]
+c: A[C]
 if int():
     c = b # E: Incompatible types in assignment (expression has type "A[B]", variable has type "A[C]")
     b = c # E: Incompatible types in assignment (expression has type "A[C]", variable has type "A[B]")
@@ -86,7 +94,9 @@ class C(B): pass
 [case testGenericTypeCompatibilityWithAny]
 from typing import Any, TypeVar, Generic
 T = TypeVar('T')
-b, c, d = None, None, None # type: (A[B], A[C], A[Any])
+b: A[B]
+c: A[C]
+d: A[Any]
 
 b = d
 c = d
@@ -102,9 +112,9 @@ class C(B): pass
 [case testTypeVariableAsTypeArgument]
 from typing import TypeVar, Generic
 T = TypeVar('T')
-a = None # type: A[B]
-b = None # type: A[B]
-c = None # type: A[C]
+a: A[B]
+b: A[B]
+c: A[C]
 
 a.v = c # E: Incompatible types in assignment (expression has type "A[C]", variable has type "A[B]")
 if int():
@@ -123,9 +133,9 @@ class C: pass
 from typing import TypeVar, Generic
 S = TypeVar('S')
 T = TypeVar('T')
-a = None # type: A[B, C]
-s = None # type: B
-t = None # type: C
+a: A[B, C]
+s: B
+t: C
 
 if int():
     t = a.s # E: Incompatible types in assignment (expression has type "B", variable has type "C")
@@ -136,8 +146,8 @@ if int():
     t = a.t
 
 class A(Generic[S, T]):
-    s = None # type: S
-    t = None # type: T
+    s: S
+    t: T
 class B: pass
 class C: pass
 
@@ -145,9 +155,9 @@ class C: pass
 from typing import TypeVar, Generic
 S = TypeVar('S')
 T = TypeVar('T')
-a = None # type: A[B, C]
-s = None # type: B
-t = None # type: C
+a: A[B, C]
+s: B
+t: C
 
 a.f(s, s) # Fail
 a.f(t, t) # Fail
@@ -165,9 +175,9 @@ main:9: error: Argument 1 to "f" of "A" has incompatible type "C"; expected "B"
 from typing import TypeVar, Generic
 S = TypeVar('S')
 T = TypeVar('T')
-bc = None # type: A[B, C]
-bb = None # type: A[B, B]
-cb = None # type: A[C, B]
+bc: A[B, C]
+bb: A[B, B]
+cb: A[C, B]
 
 if int():
     bb = bc # E: Incompatible types in assignment (expression has type "A[B, C]", variable has type "A[B, B]")
@@ -180,8 +190,8 @@ if int():
     bc = bc
 
 class A(Generic[S, T]):
-    s = None # type: S
-    t = None # type: T
+    s: S
+    t: T
 
 class B: pass
 class C(B):pass
@@ -195,7 +205,7 @@ class C(B):pass
 from typing import TypeVar, Generic
 T = TypeVar('T')
 class A(Generic[T]):
-    a = None # type: T
+    a: T
 
     def f(self, b: T) -> T:
         self.f(x)     # Fail
@@ -203,7 +213,7 @@ class A(Generic[T]):
         self.a = self.f(self.a)
         return self.a
         c = self # type: A[T]
-x = None # type: B
+x: B
 class B: pass
 [out]
 main:7: error: Argument 1 to "f" of "A" has incompatible type "B"; expected "T"
@@ -215,8 +225,8 @@ S = TypeVar('S')
 T = TypeVar('T')
 class A(Generic[S, T]):
     def f(self) -> None:
-        s = None # type: S
-        t = None # type: T
+        s: S
+        t: T
         if int():
             s = t # E: Incompatible types in assignment (expression has type "T", variable has type "S")
             t = s # E: Incompatible types in assignment (expression has type "S", variable has type "T")
@@ -230,6 +240,7 @@ class B: pass
 [out]
 
 [case testCompatibilityOfNoneWithTypeVar]
+# flags: --no-strict-optional
 from typing import TypeVar, Generic
 T = TypeVar('T')
 class A(Generic[T]):
@@ -239,6 +250,7 @@ class A(Generic[T]):
 [out]
 
 [case testCompatibilityOfTypeVarWithObject]
+# flags: --no-strict-optional
 from typing import TypeVar, Generic
 T = TypeVar('T')
 class A(Generic[T]):
@@ -261,9 +273,9 @@ class A(Generic[T]):
 from typing import TypeVar, Generic
 S = TypeVar('S')
 T = TypeVar('T')
-a = None # type: A[B, C]
-b = None # type: B
-c = None # type: C
+a: A[B, C]
+b: B
+c: C
 
 if int():
     b = a + b # E: Incompatible types in assignment (expression has type "C", variable has type "B")
@@ -286,9 +298,9 @@ class C: pass
 [case testOperatorAssignmentWithIndexLvalue1]
 from typing import TypeVar, Generic
 T = TypeVar('T')
-b = None # type: B
-c = None # type: C
-ac = None # type: A[C]
+b: B
+c: C
+ac: A[C]
 
 ac[b] += b # Fail
 ac[c] += c # Fail
@@ -309,9 +321,9 @@ main:8: error: Invalid index type "C" for "A[C]"; expected type "B"
 [case testOperatorAssignmentWithIndexLvalue2]
 from typing import TypeVar, Generic
 T = TypeVar('T')
-b = None # type: B
-c = None # type: C
-ac = None # type: A[C]
+b: B
+c: C
+ac: A[C]
 
 ac[b] += c        # Fail
 ac[c] += c        # Fail
@@ -337,10 +349,10 @@ main:9: error: Invalid index type "B" for "A[C]"; expected type "C"
 [case testNestedGenericTypes]
 from typing import TypeVar, Generic
 T = TypeVar('T')
-aab = None # type: A[A[B]]
-aac = None # type: A[A[C]]
-ab = None # type: A[B]
-ac = None # type: A[C]
+aab: A[A[B]]
+aac: A[A[C]]
+ab: A[B]
+ac: A[C]
 
 if int():
     ac = aab.x # E: Incompatible types in assignment (expression has type "A[B]", variable has type "A[C]")
@@ -353,8 +365,8 @@ ab.y = aab
 ac.y = aac
 
 class A(Generic[T]):
-    x = None # type: T
-    y = None # type: A[A[T]]
+    x: T
+    y: A[A[T]]
 
 class B:
     pass
@@ -377,12 +389,12 @@ def f(s: S, t: T) -> p[T, A]:
     a = t # type: S # E: Incompatible types in assignment (expression has type "T", variable has type "S")
     if int():
         s = t           # E: Incompatible types in assignment (expression has type "T", variable has type "S")
-    p_s_a = None  # type: p[S, A]
+    p_s_a: p[S, A]
     if s:
         return p_s_a # E: Incompatible return value type (got "p[S, A]", expected "p[T, A]")
     b = t # type: T
     c = s # type: S
-    p_t_a = None  # type: p[T, A]
+    p_t_a: p[T, A]
     return p_t_a
 [out]
 
@@ -396,16 +408,16 @@ class A(Generic[T]):
     def f(self, s: S, t: T) -> p[S, T]:
         if int():
             s = t # E: Incompatible types in assignment (expression has type "T", variable has type "S")
-        p_s_s = None  # type: p[S, S]
+        p_s_s: p[S, S]
         if s:
             return p_s_s # E: Incompatible return value type (got "p[S, S]", expected "p[S, T]")
-        p_t_t = None  # type: p[T, T]
+        p_t_t: p[T, T]
         if t:
             return p_t_t # E: Incompatible return value type (got "p[T, T]", expected "p[S, T]")
         if 1:
             t = t
             s = s
-            p_s_t = None  # type: p[S, T]
+            p_s_t: p[S, T]
             return p_s_t
 [out]
 
@@ -442,7 +454,7 @@ A[int, str, int]() # E: Type application has too many types (2 expected)
 [out]
 
 [case testInvalidTypeApplicationType]
-a = None # type: A
+a: A
 class A: pass
 a[A]()  # E: Value of type "A" is not indexable
 A[A]()  # E: The type "Type[A]" is not generic and not indexable
@@ -546,7 +558,7 @@ IntIntNode = Node[int, int]
 SameNode = Node[T, T]
 
 def output_bad() -> IntNode[str]:
-    return Node(1, 1) # Eroor - bad return type, see out
+    return Node(1, 1) # Error - bad return type, see out
 
 def input(x: IntNode[str]) -> None:
     pass
@@ -576,7 +588,7 @@ reveal_type(y) # N: Revealed type is "__main__.Node[builtins.str, builtins.str]"
 def wrap(x: T) -> IntNode[T]:
     return Node(1, x)
 
-z = None # type: str
+z: str
 reveal_type(wrap(z)) # N: Revealed type is "__main__.Node[builtins.int, builtins.str]"
 
 [out]
@@ -686,7 +698,7 @@ def output() -> IntNode[str]:
     return Node(1, 'x')
 x = output() # type: IntNode # This is OK (implicit Any)
 
-y = None # type: IntNode
+y: IntNode
 y.x = 1
 y.x = 'x' # E: Incompatible types in assignment (expression has type "str", variable has type "int")
 y.y = 1 # Both are OK (implicit Any)
@@ -707,7 +719,7 @@ class Node(Generic[T]):
         return self.x
 
 ListedNode = Node[List[T]]
-l = None # type: ListedNode[int]
+l: ListedNode[int]
 l.x.append(1)
 l.meth().append(1)
 reveal_type(l.meth()) # N: Revealed type is "builtins.list[builtins.int]"
@@ -848,7 +860,7 @@ def use_cb(arg: T, cb: C2[T]) -> Node[T]:
     return cb(arg, arg)
 
 use_cb(1, 1) # E: Argument 2 to "use_cb" has incompatible type "int"; expected "Callable[[int, int], Node[int]]"
-my_cb = None # type: C2[int]
+my_cb: C2[int]
 use_cb('x', my_cb) # E: Argument 2 to "use_cb" has incompatible type "Callable[[int, int], Node[int]]"; expected "Callable[[str, str], Node[str]]"
 reveal_type(use_cb(1, my_cb)) # N: Revealed type is "__main__.Node[builtins.int]"
 [builtins fixtures/tuple.pyi]
@@ -884,7 +896,7 @@ from typing import TypeVar
 from a import Node, TupledNode
 T = TypeVar('T')
 
-n = None # type: TupledNode[int]
+n: TupledNode[int]
 n.x = 1
 n.y = (1, 1)
 n.y = 'x' # E: Incompatible types in assignment (expression has type "str", variable has type "Tuple[int, int]")
@@ -1282,9 +1294,9 @@ from typing import List
 class A: pass
 class B: pass
 class B2(B): pass
-a = None # type: A
-b = None # type: B
-b2 = None # type: B2
+a: A
+b: B
+b2: B2
 
 list_a = [a]
 list_b = [b]
@@ -1313,8 +1325,8 @@ e, f = list_a # type: (A, object)
 
 [case testMultipleAssignmentWithListAndIndexing]
 from typing import List
-a = None # type: List[A]
-b = None # type: List[int]
+a: List[A]
+b: List[int]
 
 a[1], b[1] = a # E: Incompatible types in assignment (expression has type "A", target has type "int")
 a[1], a[2] = a
@@ -1335,8 +1347,8 @@ class dict: pass
 
 [case testMultipleAssignmentWithIterable]
 from typing import Iterable, TypeVar
-a = None  # type: int
-b = None  # type: str
+a: int
+b: str
 T = TypeVar('T')
 
 def f(x: T) -> Iterable[T]: pass
@@ -1380,7 +1392,7 @@ X = TypeVar('X')
 Y = TypeVar('Y')
 Z = TypeVar('Z')
 class OO: pass
-a = None # type: A[object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object]
+a: A[object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object]
 
 def f(a: OO) -> None:
     pass
@@ -1393,7 +1405,7 @@ class A(Generic[B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W
 from typing import TypeVar, Generic
 S = TypeVar('S')
 T = TypeVar('T')
-a = None # type: A[object, B]
+a: A[object, B]
 def f(a: 'B') -> None: pass
 
 f(a) # E: Argument 1 to "f" has incompatible type "A[object, B]"; expected "B"
@@ -1405,7 +1417,7 @@ class B: pass
 from typing import Callable, TypeVar, Generic
 S = TypeVar('S')
 T = TypeVar('T')
-a = None # type: A[object, Callable[[], None]]
+a: A[object, Callable[[], None]]
 def f(a: 'B') -> None: pass
 
 f(a) # E: Argument 1 to "f" has incompatible type "A[object, Callable[[], None]]"; expected "B"
@@ -1424,7 +1436,8 @@ from foo import *
 from typing import overload, List
 class A: pass
 class B: pass
-a, b = None, None # type: (A, B)
+a: A
+b: B
 
 @overload
 def f(a: List[A]) -> A: pass
@@ -1452,7 +1465,8 @@ def f(a: B) -> B: pass
 @overload
 def f(a: List[T]) -> T: pass
 
-a, b = None, None # type: (A, B)
+a: A
+b: B
 
 if int():
     b = f([a]) # E: Incompatible types in assignment (expression has type "A", variable has type "B")

From 8c70e8043db2c3b537bdfaa42632451950f51b68 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Thu, 6 Jul 2023 18:09:27 +0100
Subject: [PATCH 122/129] [mypyc] Support the u8 native integer type (#15564)

This is mostly similar to `i16` that I added recently in #15464, but
there are some
differences:
* Some adjustments were needed to support unsigned integers
* Add overflow checking of literals, since it's easy to over/underflow
when using `u8` due to limited range
* Rename primitive integer types from `int16` to `i16` (etc.) to match
the user-visible types (needed to get some error messages consistent,
and it's generally nicer)
* Overall make things a bit more consistent
* Actually update `mypy_extensions` stubs

This is an unsigned type to make it easier to work with binary/bytes
data. The item values for `bytes` are unsigned 8-bit values, in
particular. This type will become much more useful once we support
packed arrays.

---------

Co-authored-by: Shantanu <12621235+hauntsaninja@users.noreply.github.com>
---
 mypy/types.py                                 |   1 +
 .../stubs/mypy-extensions/mypy_extensions.pyi |  35 ++
 mypyc/codegen/emit.py                         |  11 +-
 mypyc/doc/float_operations.rst                |   2 +
 mypyc/doc/int_operations.rst                  |  42 +-
 mypyc/doc/using_type_annotations.rst          |  15 +-
 mypyc/ir/ops.py                               |   1 +
 mypyc/ir/rtypes.py                            |  77 ++-
 mypyc/irbuild/builder.py                      |   8 +-
 mypyc/irbuild/expression.py                   |  19 +-
 mypyc/irbuild/ll_builder.py                   | 101 +++-
 mypyc/irbuild/mapper.py                       |   3 +
 mypyc/irbuild/specialize.py                   |  60 +-
 mypyc/lib-rt/CPy.h                            |   2 +
 mypyc/lib-rt/int_ops.c                        |  49 ++
 mypyc/lib-rt/mypyc_util.h                     |   5 +-
 mypyc/primitives/int_ops.py                   |   8 +
 mypyc/test-data/exceptions.test               |  28 +-
 mypyc/test-data/irbuild-any.test              |   6 +-
 mypyc/test-data/irbuild-basic.test            |  60 +-
 mypyc/test-data/irbuild-bool.test             |  44 +-
 mypyc/test-data/irbuild-bytes.test            |   4 +-
 mypyc/test-data/irbuild-classes.test          |  24 +-
 mypyc/test-data/irbuild-dict.test             |  28 +-
 mypyc/test-data/irbuild-dunders.test          |   4 +-
 mypyc/test-data/irbuild-float.test            |   2 +-
 mypyc/test-data/irbuild-generics.test         |   4 +-
 mypyc/test-data/irbuild-glue-methods.test     |  24 +-
 mypyc/test-data/irbuild-i16.test              | 112 ++--
 mypyc/test-data/irbuild-i32.test              | 106 ++--
 mypyc/test-data/irbuild-i64.test              | 384 ++++++-------
 mypyc/test-data/irbuild-isinstance.test       |  16 +-
 mypyc/test-data/irbuild-lists.test            |  14 +-
 mypyc/test-data/irbuild-match.test            | 140 ++---
 mypyc/test-data/irbuild-optional.test         |  10 +-
 mypyc/test-data/irbuild-set.test              |  76 +--
 mypyc/test-data/irbuild-singledispatch.test   |   8 +-
 mypyc/test-data/irbuild-statements.test       |  32 +-
 mypyc/test-data/irbuild-str.test              |   4 +-
 mypyc/test-data/irbuild-try.test              |   8 +-
 mypyc/test-data/irbuild-tuple.test            |   2 +-
 mypyc/test-data/irbuild-u8.test               | 543 ++++++++++++++++++
 mypyc/test-data/irbuild-unreachable.test      |   4 +-
 mypyc/test-data/refcount.test                 |   6 +-
 mypyc/test-data/run-u8.test                   | 303 ++++++++++
 mypyc/test/test_irbuild.py                    |   1 +
 mypyc/test/test_ircheck.py                    |   4 +-
 mypyc/test/test_run.py                        |   1 +
 mypyc/test/test_struct.py                     |   4 +-
 test-data/unit/lib-stub/mypy_extensions.pyi   |  32 +-
 50 files changed, 1843 insertions(+), 634 deletions(-)
 create mode 100644 mypyc/test-data/irbuild-u8.test
 create mode 100644 mypyc/test-data/run-u8.test

diff --git a/mypy/types.py b/mypy/types.py
index 784ef538f197f..ba629a3553cfb 100644
--- a/mypy/types.py
+++ b/mypy/types.py
@@ -155,6 +155,7 @@
     "mypy_extensions.i64",
     "mypy_extensions.i32",
     "mypy_extensions.i16",
+    "mypy_extensions.u8",
 )
 
 DATACLASS_TRANSFORM_NAMES: Final = (
diff --git a/mypy/typeshed/stubs/mypy-extensions/mypy_extensions.pyi b/mypy/typeshed/stubs/mypy-extensions/mypy_extensions.pyi
index 86a071500b34b..b6358a0022f3b 100644
--- a/mypy/typeshed/stubs/mypy-extensions/mypy_extensions.pyi
+++ b/mypy/typeshed/stubs/mypy-extensions/mypy_extensions.pyi
@@ -181,3 +181,38 @@ class i16:
     def __ge__(self, x: i16) -> bool: ...
     def __gt__(self, x: i16) -> bool: ...
     def __index__(self) -> int: ...
+
+class u8:
+    @overload
+    def __new__(cls, __x: str | ReadableBuffer | SupportsInt | SupportsIndex | SupportsTrunc = ...) -> u8: ...
+    @overload
+    def __new__(cls, __x: str | bytes | bytearray, base: SupportsIndex) -> u8: ...
+
+    def __add__(self, x: u8) -> u8: ...
+    def __radd__(self, x: u8) -> u8: ...
+    def __sub__(self, x: u8) -> u8: ...
+    def __rsub__(self, x: u8) -> u8: ...
+    def __mul__(self, x: u8) -> u8: ...
+    def __rmul__(self, x: u8) -> u8: ...
+    def __floordiv__(self, x: u8) -> u8: ...
+    def __rfloordiv__(self, x: u8) -> u8: ...
+    def __mod__(self, x: u8) -> u8: ...
+    def __rmod__(self, x: u8) -> u8: ...
+    def __and__(self, x: u8) -> u8: ...
+    def __rand__(self, x: u8) -> u8: ...
+    def __or__(self, x: u8) -> u8: ...
+    def __ror__(self, x: u8) -> u8: ...
+    def __xor__(self, x: u8) -> u8: ...
+    def __rxor__(self, x: u8) -> u8: ...
+    def __lshift__(self, x: u8) -> u8: ...
+    def __rlshift__(self, x: u8) -> u8: ...
+    def __rshift__(self, x: u8) -> u8: ...
+    def __rrshift__(self, x: u8) -> u8: ...
+    def __neg__(self) -> u8: ...
+    def __invert__(self) -> u8: ...
+    def __pos__(self) -> u8: ...
+    def __lt__(self, x: u8) -> bool: ...
+    def __le__(self, x: u8) -> bool: ...
+    def __ge__(self, x: u8) -> bool: ...
+    def __gt__(self, x: u8) -> bool: ...
+    def __index__(self) -> int: ...
diff --git a/mypyc/codegen/emit.py b/mypyc/codegen/emit.py
index 1bd376754ab94..7d41ee7e162b6 100644
--- a/mypyc/codegen/emit.py
+++ b/mypyc/codegen/emit.py
@@ -47,6 +47,7 @@
     is_short_int_rprimitive,
     is_str_rprimitive,
     is_tuple_rprimitive,
+    is_uint8_rprimitive,
     object_rprimitive,
     optional_value_type,
 )
@@ -922,6 +923,14 @@ def emit_unbox(
             self.emit_line(f"{dest} = CPyLong_AsInt16({src});")
             if not isinstance(error, AssignHandler):
                 self.emit_unbox_failure_with_overlapping_error_value(dest, typ, failure)
+        elif is_uint8_rprimitive(typ):
+            # Whether we are borrowing or not makes no difference.
+            assert not optional  # Not supported for overlapping error values
+            if declare_dest:
+                self.emit_line(f"uint8_t {dest};")
+            self.emit_line(f"{dest} = CPyLong_AsUInt8({src});")
+            if not isinstance(error, AssignHandler):
+                self.emit_unbox_failure_with_overlapping_error_value(dest, typ, failure)
         elif is_float_rprimitive(typ):
             assert not optional  # Not supported for overlapping error values
             if declare_dest:
@@ -1013,7 +1022,7 @@ def emit_box(
             self.emit_lines(f"{declaration}{dest} = Py_None;")
             if not can_borrow:
                 self.emit_inc_ref(dest, object_rprimitive)
-        elif is_int32_rprimitive(typ) or is_int16_rprimitive(typ):
+        elif is_int32_rprimitive(typ) or is_int16_rprimitive(typ) or is_uint8_rprimitive(typ):
             self.emit_line(f"{declaration}{dest} = PyLong_FromLong({src});")
         elif is_int64_rprimitive(typ):
             self.emit_line(f"{declaration}{dest} = PyLong_FromLongLong({src});")
diff --git a/mypyc/doc/float_operations.rst b/mypyc/doc/float_operations.rst
index 1705b76724093..feae5a806c70b 100644
--- a/mypyc/doc/float_operations.rst
+++ b/mypyc/doc/float_operations.rst
@@ -15,6 +15,7 @@ Construction
 * ``float(x: i64)``
 * ``float(x: i32)``
 * ``float(x: i16)``
+* ``float(x: u8)``
 * ``float(x: str)``
 * ``float(x: float)`` (no-op)
 
@@ -32,6 +33,7 @@ Functions
 * ``i64(f)`` (convert to 64-bit signed integer)
 * ``i32(f)`` (convert to 32-bit signed integer)
 * ``i16(f)`` (convert to 16-bit signed integer)
+* ``u8(f)`` (convert to 8-bit unsigned integer)
 * ``abs(f)``
 * ``math.sin(f)``
 * ``math.cos(f)``
diff --git a/mypyc/doc/int_operations.rst b/mypyc/doc/int_operations.rst
index 88a4a9d778a1c..eb875f5c94523 100644
--- a/mypyc/doc/int_operations.rst
+++ b/mypyc/doc/int_operations.rst
@@ -9,11 +9,12 @@ Mypyc supports these integer types:
 * ``i64`` (64-bit signed integer)
 * ``i32`` (32-bit signed integer)
 * ``i16`` (16-bit signed integer)
+* ``u8`` (8-bit unsigned integer)
 
-``i64``, ``i32`` and ``i16`` are *native integer types* and must be imported
-from the ``mypy_extensions`` module. ``int`` corresponds to the Python
-``int`` type, but uses a more efficient runtime representation (tagged
-pointer). Native integer types are value types.
+``i64``, ``i32``, ``i16`` and ``u8`` are *native integer types* and
+are available in the ``mypy_extensions`` module. ``int`` corresponds
+to the Python ``int`` type, but uses a more efficient runtime
+representation (tagged pointer). Native integer types are value types.
 
 All integer types have optimized primitive operations, but the native
 integer types are more efficient than ``int``, since they don't
@@ -34,6 +35,7 @@ Construction
 * ``int(x: i64)``
 * ``int(x: i32)``
 * ``int(x: i16)``
+* ``int(x: u8)``
 * ``int(x: str)``
 * ``int(x: str, base: int)``
 * ``int(x: int)`` (no-op)
@@ -42,21 +44,23 @@ Construction
 
 * ``i64(x: int)``
 * ``i64(x: float)``
+* ``i64(x: i64)`` (no-op)
 * ``i64(x: i32)``
 * ``i64(x: i16)``
+* ``i64(x: u8)``
 * ``i64(x: str)``
 * ``i64(x: str, base: int)``
-* ``i64(x: i64)`` (no-op)
 
 ``i32`` type:
 
 * ``i32(x: int)``
 * ``i32(x: float)``
 * ``i32(x: i64)`` (truncate)
+* ``i32(x: i32)`` (no-op)
 * ``i32(x: i16)``
+* ``i32(x: u8)``
 * ``i32(x: str)``
 * ``i32(x: str, base: int)``
-* ``i32(x: i32)`` (no-op)
 
 ``i16`` type:
 
@@ -64,9 +68,10 @@ Construction
 * ``i16(x: float)``
 * ``i16(x: i64)`` (truncate)
 * ``i16(x: i32)`` (truncate)
+* ``i16(x: i16)`` (no-op)
+* ``i16(x: u8)``
 * ``i16(x: str)``
 * ``i16(x: str, base: int)``
-* ``i16(x: i16)`` (no-op)
 
 Conversions from ``int`` to a native integer type raise
 ``OverflowError`` if the value is too large or small. Conversions from
@@ -80,6 +85,8 @@ Implicit conversions
 ``int`` values can be implicitly converted to a native integer type,
 for convenience. This means that these are equivalent::
 
+   from mypy_extensions import i64
+
    def implicit() -> None:
        # Implicit conversion of 0 (int) to i64
        x: i64 = 0
@@ -107,18 +114,23 @@ Operators
 * Comparisons (``==``, ``!=``, ``<``, etc.)
 * Augmented assignment (``x += y``, etc.)
 
-If one of the above native integer operations overflows or underflows,
-the behavior is undefined. Native integer types should only be used if
-all possible values are small enough for the type. For this reason,
-the arbitrary-precision ``int`` type is recommended unless the
-performance of integer operations is critical.
+If one of the above native integer operations overflows or underflows
+with signed operands, the behavior is undefined. Signed native integer
+types should only be used if all possible values are small enough for
+the type. For this reason, the arbitrary-precision ``int`` type is
+recommended for signed values unless the performance of integer
+operations is critical.
+
+Operations on unsigned integers (``u8``) wrap around on overflow.
 
 It's a compile-time error to mix different native integer types in a
 binary operation such as addition. An explicit conversion is required::
 
-  def add(x: i64, y: i32) -> None:
-      a = x + y  # Error (i64 + i32)
-      b = x + i64(y)  # OK
+    from mypy_extensions import i64, i32
+
+    def add(x: i64, y: i32) -> None:
+        a = x + y  # Error (i64 + i32)
+        b = x + i64(y)  # OK
 
 You can freely mix a native integer value and an arbitrary-precision
 ``int`` value in an operation. The native integer type is "sticky"
diff --git a/mypyc/doc/using_type_annotations.rst b/mypyc/doc/using_type_annotations.rst
index 5bfff388e4331..04c923819d547 100644
--- a/mypyc/doc/using_type_annotations.rst
+++ b/mypyc/doc/using_type_annotations.rst
@@ -33,6 +33,7 @@ implementations:
 * ``i64`` (:ref:`documentation <native-ints>`, :ref:`native operations <int-ops>`)
 * ``i32`` (:ref:`documentation <native-ints>`, :ref:`native operations <int-ops>`)
 * ``i16`` (:ref:`documentation <native-ints>`, :ref:`native operations <int-ops>`)
+* ``u8`` (:ref:`documentation <native-ints>`, :ref:`native operations <int-ops>`)
 * ``float`` (:ref:`native operations <float-ops>`)
 * ``bool`` (:ref:`native operations <bool-ops>`)
 * ``str`` (:ref:`native operations <str-ops>`)
@@ -344,13 +345,13 @@ Native integer types
 --------------------
 
 You can use the native integer types ``i64`` (64-bit signed integer),
-``i32`` (32-bit signed integer), and ``i16`` (16-bit signed integer)
-if you know that integer values will always fit within fixed
-bounds. These types are faster than the arbitrary-precision ``int``
-type, since they don't require overflow checks on operations. ``i32``
-and ``i16`` may also use less memory than ``int`` values. The types
-are imported from the ``mypy_extensions`` module (installed via ``pip
-install mypy_extensions``).
+``i32`` (32-bit signed integer), ``i16`` (16-bit signed integer), and
+``u8`` (8-bit unsigned integer) if you know that integer values will
+always fit within fixed bounds. These types are faster than the
+arbitrary-precision ``int`` type, since they don't require overflow
+checks on operations. They may also use less memory than ``int``
+values. The types are imported from the ``mypy_extensions`` module
+(installed via ``pip install mypy_extensions``).
 
 Example::
 
diff --git a/mypyc/ir/ops.py b/mypyc/ir/ops.py
index cb8d9662820c5..d80c479211b7b 100644
--- a/mypyc/ir/ops.py
+++ b/mypyc/ir/ops.py
@@ -1162,6 +1162,7 @@ class ComparisonOp(RegisterOp):
     }
 
     signed_ops: Final = {"==": EQ, "!=": NEQ, "<": SLT, ">": SGT, "<=": SLE, ">=": SGE}
+    unsigned_ops: Final = {"==": EQ, "!=": NEQ, "<": ULT, ">": UGT, "<=": ULE, ">=": UGE}
 
     def __init__(self, lhs: Value, rhs: Value, op: int, line: int = -1) -> None:
         super().__init__(line)
diff --git a/mypyc/ir/rtypes.py b/mypyc/ir/rtypes.py
index fe0c51ea2221d..fa46feb0b59ad 100644
--- a/mypyc/ir/rtypes.py
+++ b/mypyc/ir/rtypes.py
@@ -23,7 +23,8 @@
 from __future__ import annotations
 
 from abc import abstractmethod
-from typing import TYPE_CHECKING, ClassVar, Final, Generic, TypeVar
+from typing import TYPE_CHECKING, ClassVar, Generic, TypeVar
+from typing_extensions import Final, TypeGuard
 
 from mypyc.common import IS_32_BIT_PLATFORM, PLATFORM_SIZE, JsonDict, short_name
 from mypyc.namegen import NameGenerator
@@ -209,9 +210,8 @@ def __init__(
             # This is basically an arbitrary value that is pretty
             # unlikely to overlap with a real value.
             self.c_undefined = "-113"
-        elif ctype in ("CPyPtr", "uint32_t", "uint64_t"):
-            # TODO: For low-level integers, we need to invent an overlapping
-            #       error value, similar to int64_t above.
+        elif ctype == "CPyPtr":
+            # TODO: Invent an overlapping error value?
             self.c_undefined = "0"
         elif ctype == "PyObject *":
             # Boxed types use the null pointer as the error value.
@@ -222,6 +222,8 @@ def __init__(
             self.c_undefined = "NULL"
         elif ctype == "double":
             self.c_undefined = "-113.0"
+        elif ctype in ("uint8_t", "uint16_t", "uint32_t", "uint64_t"):
+            self.c_undefined = "239"  # An arbitrary number
         else:
             assert False, "Unrecognized ctype: %r" % ctype
 
@@ -290,7 +292,7 @@ def __hash__(self) -> int:
 # Low level integer types (correspond to C integer types)
 
 int16_rprimitive: Final = RPrimitive(
-    "int16",
+    "i16",
     is_unboxed=True,
     is_refcounted=False,
     is_native_int=True,
@@ -300,7 +302,7 @@ def __hash__(self) -> int:
     error_overlap=True,
 )
 int32_rprimitive: Final = RPrimitive(
-    "int32",
+    "i32",
     is_unboxed=True,
     is_refcounted=False,
     is_native_int=True,
@@ -310,7 +312,7 @@ def __hash__(self) -> int:
     error_overlap=True,
 )
 int64_rprimitive: Final = RPrimitive(
-    "int64",
+    "i64",
     is_unboxed=True,
     is_refcounted=False,
     is_native_int=True,
@@ -319,23 +321,49 @@ def __hash__(self) -> int:
     size=8,
     error_overlap=True,
 )
+uint8_rprimitive: Final = RPrimitive(
+    "u8",
+    is_unboxed=True,
+    is_refcounted=False,
+    is_native_int=True,
+    is_signed=False,
+    ctype="uint8_t",
+    size=1,
+    error_overlap=True,
+)
+
+# The following unsigned native int types (u16, u32, u64) are not
+# exposed to the user. They are for internal use within mypyc only.
+
+u16_rprimitive: Final = RPrimitive(
+    "u16",
+    is_unboxed=True,
+    is_refcounted=False,
+    is_native_int=True,
+    is_signed=False,
+    ctype="uint16_t",
+    size=2,
+    error_overlap=True,
+)
 uint32_rprimitive: Final = RPrimitive(
-    "uint32",
+    "u32",
     is_unboxed=True,
     is_refcounted=False,
     is_native_int=True,
     is_signed=False,
     ctype="uint32_t",
     size=4,
+    error_overlap=True,
 )
 uint64_rprimitive: Final = RPrimitive(
-    "uint64",
+    "u64",
     is_unboxed=True,
     is_refcounted=False,
     is_native_int=True,
     is_signed=False,
     ctype="uint64_t",
     size=8,
+    error_overlap=True,
 )
 
 # The C 'int' type
@@ -441,11 +469,11 @@ def is_short_int_rprimitive(rtype: RType) -> bool:
     return rtype is short_int_rprimitive
 
 
-def is_int16_rprimitive(rtype: RType) -> bool:
+def is_int16_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
     return rtype is int16_rprimitive
 
 
-def is_int32_rprimitive(rtype: RType) -> bool:
+def is_int32_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
     return rtype is int32_rprimitive or (
         rtype is c_pyssize_t_rprimitive and rtype._ctype == "int32_t"
     )
@@ -457,8 +485,17 @@ def is_int64_rprimitive(rtype: RType) -> bool:
     )
 
 
-def is_fixed_width_rtype(rtype: RType) -> bool:
-    return is_int64_rprimitive(rtype) or is_int32_rprimitive(rtype) or is_int16_rprimitive(rtype)
+def is_fixed_width_rtype(rtype: RType) -> TypeGuard[RPrimitive]:
+    return (
+        is_int64_rprimitive(rtype)
+        or is_int32_rprimitive(rtype)
+        or is_int16_rprimitive(rtype)
+        or is_uint8_rprimitive(rtype)
+    )
+
+
+def is_uint8_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return rtype is uint8_rprimitive
 
 
 def is_uint32_rprimitive(rtype: RType) -> bool:
@@ -551,6 +588,8 @@ def visit_rprimitive(self, t: RPrimitive) -> str:
             return "4"  # "4 byte integer"
         elif t._ctype == "int16_t":
             return "2"  # "2 byte integer"
+        elif t._ctype == "uint8_t":
+            return "U1"  # "1 byte unsigned integer"
         elif t._ctype == "double":
             return "F"
         assert not t.is_unboxed, f"{t} unexpected unboxed type"
@@ -985,3 +1024,15 @@ def deserialize(cls, data: JsonDict, ctx: DeserMaps) -> RArray:
     names=["ob_base", "ob_item", "allocated"],
     types=[PyVarObject, pointer_rprimitive, c_pyssize_t_rprimitive],
 )
+
+
+def check_native_int_range(rtype: RPrimitive, n: int) -> bool:
+    """Is n within the range of a native, fixed-width int type?
+
+    Assume the type is a fixed-width int type.
+    """
+    if not rtype.is_signed:
+        return 0 <= n < (1 << (8 * rtype.size))
+    else:
+        limit = 1 << (rtype.size * 8 - 1)
+        return -limit <= n < limit
diff --git a/mypyc/irbuild/builder.py b/mypyc/irbuild/builder.py
index 10f057a29bbb9..8c68f91bf6339 100644
--- a/mypyc/irbuild/builder.py
+++ b/mypyc/irbuild/builder.py
@@ -159,7 +159,7 @@ def __init__(
         options: CompilerOptions,
         singledispatch_impls: dict[FuncDef, list[RegisterImplInfo]],
     ) -> None:
-        self.builder = LowLevelIRBuilder(current_module, mapper, options)
+        self.builder = LowLevelIRBuilder(current_module, errors, mapper, options)
         self.builders = [self.builder]
         self.symtables: list[dict[SymbolNode, SymbolTarget]] = [{}]
         self.runtime_args: list[list[RuntimeArg]] = [[]]
@@ -224,6 +224,7 @@ def set_module(self, module_name: str, module_path: str) -> None:
         """
         self.module_name = module_name
         self.module_path = module_path
+        self.builder.set_module(module_name, module_path)
 
     @overload
     def accept(self, node: Expression, *, can_borrow: bool = False) -> Value:
@@ -1102,7 +1103,10 @@ def flatten_classes(self, arg: RefExpr | TupleExpr) -> list[ClassIR] | None:
     def enter(self, fn_info: FuncInfo | str = "") -> None:
         if isinstance(fn_info, str):
             fn_info = FuncInfo(name=fn_info)
-        self.builder = LowLevelIRBuilder(self.current_module, self.mapper, self.options)
+        self.builder = LowLevelIRBuilder(
+            self.current_module, self.errors, self.mapper, self.options
+        )
+        self.builder.set_module(self.module_name, self.module_path)
         self.builders.append(self.builder)
         self.symtables.append({})
         self.runtime_args.append([])
diff --git a/mypyc/irbuild/expression.py b/mypyc/irbuild/expression.py
index ada3d47cefab0..8d205b432d2d5 100644
--- a/mypyc/irbuild/expression.py
+++ b/mypyc/irbuild/expression.py
@@ -815,21 +815,30 @@ def transform_basic_comparison(
         return builder.compare_tagged(left, right, op, line)
     if is_fixed_width_rtype(left.type) and op in int_comparison_op_mapping:
         if right.type == left.type:
-            op_id = ComparisonOp.signed_ops[op]
+            if left.type.is_signed:
+                op_id = ComparisonOp.signed_ops[op]
+            else:
+                op_id = ComparisonOp.unsigned_ops[op]
             return builder.builder.comparison_op(left, right, op_id, line)
         elif isinstance(right, Integer):
-            op_id = ComparisonOp.signed_ops[op]
+            if left.type.is_signed:
+                op_id = ComparisonOp.signed_ops[op]
+            else:
+                op_id = ComparisonOp.unsigned_ops[op]
             return builder.builder.comparison_op(
-                left, Integer(right.value >> 1, left.type), op_id, line
+                left, builder.coerce(right, left.type, line), op_id, line
             )
     elif (
         is_fixed_width_rtype(right.type)
         and op in int_comparison_op_mapping
         and isinstance(left, Integer)
     ):
-        op_id = ComparisonOp.signed_ops[op]
+        if right.type.is_signed:
+            op_id = ComparisonOp.signed_ops[op]
+        else:
+            op_id = ComparisonOp.unsigned_ops[op]
         return builder.builder.comparison_op(
-            Integer(left.value >> 1, right.type), right, op_id, line
+            builder.coerce(left, right.type, line), right, op_id, line
         )
 
     negate = False
diff --git a/mypyc/irbuild/ll_builder.py b/mypyc/irbuild/ll_builder.py
index e34f037040476..984b6a4deec0f 100644
--- a/mypyc/irbuild/ll_builder.py
+++ b/mypyc/irbuild/ll_builder.py
@@ -27,6 +27,7 @@
     use_method_vectorcall,
     use_vectorcall,
 )
+from mypyc.errors import Errors
 from mypyc.ir.class_ir import ClassIR, all_concrete_classes
 from mypyc.ir.func_ir import FuncDecl, FuncSignature
 from mypyc.ir.ops import (
@@ -94,6 +95,7 @@
     c_pointer_rprimitive,
     c_pyssize_t_rprimitive,
     c_size_t_rprimitive,
+    check_native_int_range,
     dict_rprimitive,
     float_rprimitive,
     int_rprimitive,
@@ -114,6 +116,7 @@
     is_str_rprimitive,
     is_tagged,
     is_tuple_rprimitive,
+    is_uint8_rprimitive,
     list_rprimitive,
     none_rprimitive,
     object_pointer_rprimitive,
@@ -159,6 +162,7 @@
     int_to_int32_op,
     int_to_int64_op,
     ssize_t_to_int_op,
+    uint8_overflow,
 )
 from mypyc.primitives.list_ops import list_build_op, list_extend_op, new_list_op
 from mypyc.primitives.misc_ops import bool_op, fast_isinstance_op, none_object_op
@@ -216,8 +220,11 @@
 
 
 class LowLevelIRBuilder:
-    def __init__(self, current_module: str, mapper: Mapper, options: CompilerOptions) -> None:
+    def __init__(
+        self, current_module: str, errors: Errors, mapper: Mapper, options: CompilerOptions
+    ) -> None:
         self.current_module = current_module
+        self.errors = errors
         self.mapper = mapper
         self.options = options
         self.args: list[Register] = []
@@ -228,6 +235,11 @@ def __init__(self, current_module: str, mapper: Mapper, options: CompilerOptions
         # temporaries. Use flush_keep_alives() to mark the end of the live range.
         self.keep_alives: list[Value] = []
 
+    def set_module(self, module_name: str, module_path: str) -> None:
+        """Set the name and path of the current module."""
+        self.module_name = module_name
+        self.module_path = module_path
+
     # Basic operations
 
     def add(self, op: Op) -> Value:
@@ -323,7 +335,9 @@ def coerce(
                 and is_short_int_rprimitive(src_type)
                 and is_fixed_width_rtype(target_type)
             ):
-                # TODO: range check
+                value = src.numeric_value()
+                if not check_native_int_range(target_type, value):
+                    self.error(f'Value {value} is out of range for "{target_type}"', line)
                 return Integer(src.value >> 1, target_type)
             elif is_int_rprimitive(src_type) and is_fixed_width_rtype(target_type):
                 return self.coerce_int_to_fixed_width(src, target_type, line)
@@ -413,10 +427,16 @@ def coerce_int_to_fixed_width(self, src: Value, target_type: RType, line: int) -
             # Add a range check when the target type is smaller than the source tyoe
             fast2, fast3 = BasicBlock(), BasicBlock()
             upper_bound = 1 << (size * 8 - 1)
+            if not target_type.is_signed:
+                upper_bound *= 2
             check2 = self.add(ComparisonOp(src, Integer(upper_bound, src.type), ComparisonOp.SLT))
             self.add(Branch(check2, fast2, slow, Branch.BOOL))
             self.activate_block(fast2)
-            check3 = self.add(ComparisonOp(src, Integer(-upper_bound, src.type), ComparisonOp.SGE))
+            if target_type.is_signed:
+                lower_bound = -upper_bound
+            else:
+                lower_bound = 0
+            check3 = self.add(ComparisonOp(src, Integer(lower_bound, src.type), ComparisonOp.SGE))
             self.add(Branch(check3, fast3, slow, Branch.BOOL))
             self.activate_block(fast3)
             tmp = self.int_op(
@@ -463,6 +483,10 @@ def coerce_int_to_fixed_width(self, src: Value, target_type: RType, line: int) -
             # Slow path just always generates an OverflowError
             self.call_c(int16_overflow, [], line)
             self.add(Unreachable())
+        elif is_uint8_rprimitive(target_type):
+            # Slow path just always generates an OverflowError
+            self.call_c(uint8_overflow, [], line)
+            self.add(Unreachable())
         else:
             assert False, target_type
 
@@ -476,9 +500,13 @@ def coerce_short_int_to_fixed_width(self, src: Value, target_type: RType, line:
         assert False, (src.type, target_type)
 
     def coerce_fixed_width_to_int(self, src: Value, line: int) -> Value:
-        if (is_int32_rprimitive(src.type) and PLATFORM_SIZE == 8) or is_int16_rprimitive(src.type):
+        if (
+            (is_int32_rprimitive(src.type) and PLATFORM_SIZE == 8)
+            or is_int16_rprimitive(src.type)
+            or is_uint8_rprimitive(src.type)
+        ):
             # Simple case -- just sign extend and shift.
-            extended = self.add(Extend(src, c_pyssize_t_rprimitive, signed=True))
+            extended = self.add(Extend(src, c_pyssize_t_rprimitive, signed=src.type.is_signed))
             return self.int_op(
                 int_rprimitive,
                 extended,
@@ -1310,9 +1338,8 @@ def binary_op(self, lreg: Value, rreg: Value, op: str, line: int) -> Value:
                 if is_fixed_width_rtype(rtype) or is_tagged(rtype):
                     return self.fixed_width_int_op(ltype, lreg, rreg, op_id, line)
                 if isinstance(rreg, Integer):
-                    # TODO: Check what kind of Integer
                     return self.fixed_width_int_op(
-                        ltype, lreg, Integer(rreg.value >> 1, ltype), op_id, line
+                        ltype, lreg, self.coerce(rreg, ltype, line), op_id, line
                     )
             elif op in ComparisonOp.signed_ops:
                 if is_int_rprimitive(rtype):
@@ -1323,7 +1350,7 @@ def binary_op(self, lreg: Value, rreg: Value, op: str, line: int) -> Value:
                 if is_fixed_width_rtype(rreg.type):
                     return self.comparison_op(lreg, rreg, op_id, line)
                 if isinstance(rreg, Integer):
-                    return self.comparison_op(lreg, Integer(rreg.value >> 1, ltype), op_id, line)
+                    return self.comparison_op(lreg, self.coerce(rreg, ltype, line), op_id, line)
         elif is_fixed_width_rtype(rtype):
             if op in FIXED_WIDTH_INT_BINARY_OPS:
                 if op.endswith("="):
@@ -1333,9 +1360,8 @@ def binary_op(self, lreg: Value, rreg: Value, op: str, line: int) -> Value:
                 else:
                     op_id = IntOp.DIV
                 if isinstance(lreg, Integer):
-                    # TODO: Check what kind of Integer
                     return self.fixed_width_int_op(
-                        rtype, Integer(lreg.value >> 1, rtype), rreg, op_id, line
+                        rtype, self.coerce(lreg, rtype, line), rreg, op_id, line
                     )
                 if is_tagged(ltype):
                     return self.fixed_width_int_op(rtype, lreg, rreg, op_id, line)
@@ -1349,7 +1375,7 @@ def binary_op(self, lreg: Value, rreg: Value, op: str, line: int) -> Value:
                     lreg = self.coerce(lreg, rtype, line)
                 op_id = ComparisonOp.signed_ops[op]
                 if isinstance(lreg, Integer):
-                    return self.comparison_op(Integer(lreg.value >> 1, rtype), rreg, op_id, line)
+                    return self.comparison_op(self.coerce(lreg, rtype, line), rreg, op_id, line)
                 if is_fixed_width_rtype(lreg.type):
                     return self.comparison_op(lreg, rreg, op_id, line)
 
@@ -1611,8 +1637,13 @@ def unary_op(self, value: Value, expr_op: str, line: int) -> Value:
                 # Translate to '0 - x'
                 return self.int_op(typ, Integer(0, typ), value, IntOp.SUB, line)
             elif expr_op == "~":
-                # Translate to 'x ^ -1'
-                return self.int_op(typ, value, Integer(-1, typ), IntOp.XOR, line)
+                if typ.is_signed:
+                    # Translate to 'x ^ -1'
+                    return self.int_op(typ, value, Integer(-1, typ), IntOp.XOR, line)
+                else:
+                    # Translate to 'x ^ 0xff...'
+                    mask = (1 << (typ.size * 8)) - 1
+                    return self.int_op(typ, value, Integer(mask, typ), IntOp.XOR, line)
             elif expr_op == "+":
                 return value
         if is_float_rprimitive(typ):
@@ -2025,7 +2056,9 @@ def float_mod(self, lhs: Value, rhs: Value, line: int) -> Value:
     def compare_floats(self, lhs: Value, rhs: Value, op: int, line: int) -> Value:
         return self.add(FloatComparisonOp(lhs, rhs, op, line))
 
-    def fixed_width_int_op(self, type: RType, lhs: Value, rhs: Value, op: int, line: int) -> Value:
+    def fixed_width_int_op(
+        self, type: RPrimitive, lhs: Value, rhs: Value, op: int, line: int
+    ) -> Value:
         """Generate a binary op using Python fixed-width integer semantics.
 
         These may differ in overflow/rounding behavior from native/C ops.
@@ -2037,35 +2070,60 @@ def fixed_width_int_op(self, type: RType, lhs: Value, rhs: Value, op: int, line:
         lhs = self.coerce(lhs, type, line)
         rhs = self.coerce(rhs, type, line)
         if op == IntOp.DIV:
-            # Inline simple division by a constant, so that C
-            # compilers can optimize more
             if isinstance(rhs, Integer) and rhs.value not in (-1, 0):
-                return self.inline_fixed_width_divide(type, lhs, rhs, line)
+                if not type.is_signed:
+                    return self.int_op(type, lhs, rhs, IntOp.DIV, line)
+                else:
+                    # Inline simple division by a constant, so that C
+                    # compilers can optimize more
+                    return self.inline_fixed_width_divide(type, lhs, rhs, line)
             if is_int64_rprimitive(type):
                 prim = int64_divide_op
             elif is_int32_rprimitive(type):
                 prim = int32_divide_op
             elif is_int16_rprimitive(type):
                 prim = int16_divide_op
+            elif is_uint8_rprimitive(type):
+                self.check_for_zero_division(rhs, type, line)
+                return self.int_op(type, lhs, rhs, op, line)
             else:
                 assert False, type
             return self.call_c(prim, [lhs, rhs], line)
         if op == IntOp.MOD:
-            # Inline simple % by a constant, so that C
-            # compilers can optimize more
             if isinstance(rhs, Integer) and rhs.value not in (-1, 0):
-                return self.inline_fixed_width_mod(type, lhs, rhs, line)
+                if not type.is_signed:
+                    return self.int_op(type, lhs, rhs, IntOp.MOD, line)
+                else:
+                    # Inline simple % by a constant, so that C
+                    # compilers can optimize more
+                    return self.inline_fixed_width_mod(type, lhs, rhs, line)
             if is_int64_rprimitive(type):
                 prim = int64_mod_op
             elif is_int32_rprimitive(type):
                 prim = int32_mod_op
             elif is_int16_rprimitive(type):
                 prim = int16_mod_op
+            elif is_uint8_rprimitive(type):
+                self.check_for_zero_division(rhs, type, line)
+                return self.int_op(type, lhs, rhs, op, line)
             else:
                 assert False, type
             return self.call_c(prim, [lhs, rhs], line)
         return self.int_op(type, lhs, rhs, op, line)
 
+    def check_for_zero_division(self, rhs: Value, type: RType, line: int) -> None:
+        err, ok = BasicBlock(), BasicBlock()
+        is_zero = self.binary_op(rhs, Integer(0, type), "==", line)
+        self.add(Branch(is_zero, err, ok, Branch.BOOL))
+        self.activate_block(err)
+        self.add(
+            RaiseStandardError(
+                RaiseStandardError.ZERO_DIVISION_ERROR, "integer division or modulo by zero", line
+            )
+        )
+        self.add(Unreachable())
+        self.activate_block(ok)
+
     def inline_fixed_width_divide(self, type: RType, lhs: Value, rhs: Value, line: int) -> Value:
         # Perform floor division (native division truncates)
         res = Register(type)
@@ -2332,6 +2390,9 @@ def _create_dict(self, keys: list[Value], values: list[Value], line: int) -> Val
         else:
             return self.call_c(dict_new_op, [], line)
 
+    def error(self, msg: str, line: int) -> None:
+        self.errors.error(msg, self.module_path, line)
+
 
 def num_positional_args(arg_values: list[Value], arg_kinds: list[ArgKind] | None) -> int:
     if arg_kinds is None:
diff --git a/mypyc/irbuild/mapper.py b/mypyc/irbuild/mapper.py
index a4712f4af524c..5b77b4b1537b2 100644
--- a/mypyc/irbuild/mapper.py
+++ b/mypyc/irbuild/mapper.py
@@ -43,6 +43,7 @@
     set_rprimitive,
     str_rprimitive,
     tuple_rprimitive,
+    uint8_rprimitive,
 )
 
 
@@ -105,6 +106,8 @@ def type_to_rtype(self, typ: Type | None) -> RType:
                 return int32_rprimitive
             elif typ.type.fullname == "mypy_extensions.i16":
                 return int16_rprimitive
+            elif typ.type.fullname == "mypy_extensions.u8":
+                return uint8_rprimitive
             else:
                 return object_rprimitive
         elif isinstance(typ, TupleType):
diff --git a/mypyc/irbuild/specialize.py b/mypyc/irbuild/specialize.py
index 2f22b4bfc9d20..7c59584578866 100644
--- a/mypyc/irbuild/specialize.py
+++ b/mypyc/irbuild/specialize.py
@@ -44,6 +44,7 @@
 )
 from mypyc.ir.rtypes import (
     RInstance,
+    RPrimitive,
     RTuple,
     RType,
     bool_rprimitive,
@@ -62,9 +63,11 @@
     is_int64_rprimitive,
     is_int_rprimitive,
     is_list_rprimitive,
+    is_uint8_rprimitive,
     list_rprimitive,
     set_rprimitive,
     str_rprimitive,
+    uint8_rprimitive,
 )
 from mypyc.irbuild.builder import IRBuilder
 from mypyc.irbuild.for_helpers import (
@@ -166,15 +169,19 @@ def translate_globals(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Va
 @specialize_function("mypy_extensions.i64")
 @specialize_function("mypy_extensions.i32")
 @specialize_function("mypy_extensions.i16")
+@specialize_function("mypy_extensions.u8")
 def translate_builtins_with_unary_dunder(
     builder: IRBuilder, expr: CallExpr, callee: RefExpr
 ) -> Value | None:
-    """Specialize calls on native classes that implement the associated dunder."""
+    """Specialize calls on native classes that implement the associated dunder.
+
+    E.g. i64(x) gets specialized to x.__int__() if x is a native instance.
+    """
     if len(expr.args) == 1 and expr.arg_kinds == [ARG_POS] and isinstance(callee, NameExpr):
         arg = expr.args[0]
         arg_typ = builder.node_type(arg)
         shortname = callee.fullname.split(".")[1]
-        if shortname in ("i64", "i32", "i16"):
+        if shortname in ("i64", "i32", "i16", "u8"):
             method = "__int__"
         else:
             method = f"__{shortname}__"
@@ -686,6 +693,9 @@ def translate_i64(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value
     elif is_int32_rprimitive(arg_type) or is_int16_rprimitive(arg_type):
         val = builder.accept(arg)
         return builder.add(Extend(val, int64_rprimitive, signed=True, line=expr.line))
+    elif is_uint8_rprimitive(arg_type):
+        val = builder.accept(arg)
+        return builder.add(Extend(val, int64_rprimitive, signed=False, line=expr.line))
     elif is_int_rprimitive(arg_type) or is_bool_rprimitive(arg_type):
         val = builder.accept(arg)
         return builder.coerce(val, int64_rprimitive, expr.line)
@@ -706,8 +716,12 @@ def translate_i32(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value
     elif is_int16_rprimitive(arg_type):
         val = builder.accept(arg)
         return builder.add(Extend(val, int32_rprimitive, signed=True, line=expr.line))
+    elif is_uint8_rprimitive(arg_type):
+        val = builder.accept(arg)
+        return builder.add(Extend(val, int32_rprimitive, signed=False, line=expr.line))
     elif is_int_rprimitive(arg_type) or is_bool_rprimitive(arg_type):
         val = builder.accept(arg)
+        val = truncate_literal(val, int32_rprimitive)
         return builder.coerce(val, int32_rprimitive, expr.line)
     return None
 
@@ -723,12 +737,54 @@ def translate_i16(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value
     elif is_int32_rprimitive(arg_type) or is_int64_rprimitive(arg_type):
         val = builder.accept(arg)
         return builder.add(Truncate(val, int16_rprimitive, line=expr.line))
+    elif is_uint8_rprimitive(arg_type):
+        val = builder.accept(arg)
+        return builder.add(Extend(val, int16_rprimitive, signed=False, line=expr.line))
     elif is_int_rprimitive(arg_type) or is_bool_rprimitive(arg_type):
         val = builder.accept(arg)
+        val = truncate_literal(val, int16_rprimitive)
         return builder.coerce(val, int16_rprimitive, expr.line)
     return None
 
 
+@specialize_function("mypy_extensions.u8")
+def translate_u8(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
+    if len(expr.args) != 1 or expr.arg_kinds[0] != ARG_POS:
+        return None
+    arg = expr.args[0]
+    arg_type = builder.node_type(arg)
+    if is_uint8_rprimitive(arg_type):
+        return builder.accept(arg)
+    elif (
+        is_int16_rprimitive(arg_type)
+        or is_int32_rprimitive(arg_type)
+        or is_int64_rprimitive(arg_type)
+    ):
+        val = builder.accept(arg)
+        return builder.add(Truncate(val, uint8_rprimitive, line=expr.line))
+    elif is_int_rprimitive(arg_type) or is_bool_rprimitive(arg_type):
+        val = builder.accept(arg)
+        val = truncate_literal(val, uint8_rprimitive)
+        return builder.coerce(val, uint8_rprimitive, expr.line)
+    return None
+
+
+def truncate_literal(value: Value, rtype: RPrimitive) -> Value:
+    """If value is an integer literal value, truncate it to given native int rtype.
+
+    For example, truncate 256 into 0 if rtype is u8.
+    """
+    if not isinstance(value, Integer):
+        return value  # Not a literal, nothing to do
+    x = value.numeric_value()
+    max_unsigned = (1 << (rtype.size * 8)) - 1
+    x = x & max_unsigned
+    if rtype.is_signed and x >= (max_unsigned + 1) // 2:
+        # Adjust to make it a negative value
+        x -= max_unsigned + 1
+    return Integer(x, rtype)
+
+
 @specialize_function("builtins.int")
 def translate_int(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
     if len(expr.args) != 1 or expr.arg_kinds[0] != ARG_POS:
diff --git a/mypyc/lib-rt/CPy.h b/mypyc/lib-rt/CPy.h
index 689526e0e8266..64b716945b944 100644
--- a/mypyc/lib-rt/CPy.h
+++ b/mypyc/lib-rt/CPy.h
@@ -159,6 +159,8 @@ int16_t CPyLong_AsInt16(PyObject *o);
 int16_t CPyInt16_Divide(int16_t x, int16_t y);
 int16_t CPyInt16_Remainder(int16_t x, int16_t y);
 void CPyInt16_Overflow(void);
+uint8_t CPyLong_AsUInt8(PyObject *o);
+void CPyUInt8_Overflow(void);
 double CPyTagged_TrueDivide(CPyTagged x, CPyTagged y);
 
 static inline int CPyTagged_CheckLong(CPyTagged x) {
diff --git a/mypyc/lib-rt/int_ops.c b/mypyc/lib-rt/int_ops.c
index 528401692a3a6..b57d88c6ac934 100644
--- a/mypyc/lib-rt/int_ops.c
+++ b/mypyc/lib-rt/int_ops.c
@@ -734,6 +734,55 @@ void CPyInt16_Overflow() {
     PyErr_SetString(PyExc_OverflowError, "int too large to convert to i16");
 }
 
+
+uint8_t CPyLong_AsUInt8(PyObject *o) {
+    if (likely(PyLong_Check(o))) {
+    #if CPY_3_12_FEATURES
+        PyLongObject *lobj = (PyLongObject *)o;
+        size_t tag = CPY_LONG_TAG(lobj);
+        if (likely(tag == (1 << CPY_NON_SIZE_BITS))) {
+            // Fast path
+            digit x = CPY_LONG_DIGIT(lobj, 0);
+            if (x < 256)
+                return x;
+        } else if (likely(tag == CPY_SIGN_ZERO)) {
+            return 0;
+        }
+    #else
+        PyLongObject *lobj = (PyLongObject *)o;
+        Py_ssize_t size = lobj->ob_base.ob_size;
+        if (likely(size == 1)) {
+            // Fast path
+            digit x = lobj->ob_digit[0];
+            if (x < 256)
+                return x;
+        } else if (likely(size == 0)) {
+            return 0;
+        }
+    #endif
+    }
+    // Slow path
+    int overflow;
+    long result = PyLong_AsLongAndOverflow(o, &overflow);
+    if (result < 0 || result >= 256) {
+        overflow = 1;
+        result = -1;
+    }
+    if (result == -1) {
+        if (PyErr_Occurred()) {
+            return CPY_LL_UINT_ERROR;
+        } else if (overflow) {
+            PyErr_SetString(PyExc_OverflowError, "int too large or small to convert to u8");
+            return CPY_LL_UINT_ERROR;
+        }
+    }
+    return result;
+}
+
+void CPyUInt8_Overflow() {
+    PyErr_SetString(PyExc_OverflowError, "int too large or small to convert to u8");
+}
+
 double CPyTagged_TrueDivide(CPyTagged x, CPyTagged y) {
     if (unlikely(y == 0)) {
         PyErr_SetString(PyExc_ZeroDivisionError, "division by zero");
diff --git a/mypyc/lib-rt/mypyc_util.h b/mypyc/lib-rt/mypyc_util.h
index e7e9fd7687157..3c888a581a33f 100644
--- a/mypyc/lib-rt/mypyc_util.h
+++ b/mypyc/lib-rt/mypyc_util.h
@@ -53,9 +53,12 @@ typedef PyObject CPyModule;
 // Tag bit used for long integers
 #define CPY_INT_TAG 1
 
-// Error value for fixed-width (low-level) integers
+// Error value for signed fixed-width (low-level) integers
 #define CPY_LL_INT_ERROR -113
 
+// Error value for unsigned fixed-width (low-level) integers
+#define CPY_LL_UINT_ERROR 239
+
 // Error value for floats
 #define CPY_FLOAT_ERROR -113.0
 
diff --git a/mypyc/primitives/int_ops.py b/mypyc/primitives/int_ops.py
index ef79bbc51ce69..95f9cc5ff43f1 100644
--- a/mypyc/primitives/int_ops.py
+++ b/mypyc/primitives/int_ops.py
@@ -43,6 +43,7 @@
     "mypy_extensions.i64",
     "mypy_extensions.i32",
     "mypy_extensions.i16",
+    "mypy_extensions.u8",
 ):
     # These int constructors produce object_rprimitives that then need to be unboxed
     # I guess unboxing ourselves would save a check and branch though?
@@ -294,3 +295,10 @@ class IntComparisonOpDescription(NamedTuple):
     c_function_name="CPyInt16_Overflow",
     error_kind=ERR_ALWAYS,
 )
+
+uint8_overflow = custom_op(
+    arg_types=[],
+    return_type=void_rtype,
+    c_function_name="CPyUInt8_Overflow",
+    error_kind=ERR_ALWAYS,
+)
diff --git a/mypyc/test-data/exceptions.test b/mypyc/test-data/exceptions.test
index 16bf8ba1eb89d..ed43b86ebdb44 100644
--- a/mypyc/test-data/exceptions.test
+++ b/mypyc/test-data/exceptions.test
@@ -34,7 +34,7 @@ def f(x, y, z):
     x :: list
     y, z :: int
     r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3 :: object
     r4 :: bit
@@ -528,10 +528,10 @@ def f():
 L0:
     return 0
 def g():
-    r0 :: int64
+    r0 :: i64
     r1 :: bit
     r2 :: object
-    r3 :: int64
+    r3 :: i64
 L0:
     r0 = f()
     r1 = r0 == -113
@@ -542,7 +542,7 @@ L2:
     r2 = PyErr_Occurred()
     if not is_error(r2) goto L3 (error at g:7) else goto L1
 L3:
-    r3 = <error> :: int64
+    r3 = <error> :: i64
     return r3
 
 [case testExceptionWithNativeAttributeGetAndSet]
@@ -612,16 +612,16 @@ def f(c: C) -> None:
 [out]
 def C.__init__(self, x, y):
     self :: __main__.C
-    x :: int32
-    y :: int64
+    x :: i32
+    y :: i64
 L0:
     self.x = x
     self.y = y
     return 1
 def f(c):
     c :: __main__.C
-    r0 :: int32
-    r1 :: int64
+    r0 :: i32
+    r1 :: i64
 L0:
     r0 = c.x
     r1 = c.y
@@ -636,15 +636,15 @@ def f(x: i64) -> i64:
     return y
 [out]
 def f(x):
-    x, r0, y :: int64
-    __locals_bitmap0 :: uint32
+    x, r0, y :: i64
+    __locals_bitmap0 :: u32
     r1 :: bit
-    r2, r3 :: uint32
+    r2, r3 :: u32
     r4 :: bit
     r5 :: bool
-    r6 :: int64
+    r6 :: i64
 L0:
-    r0 = <error> :: int64
+    r0 = <error> :: i64
     y = r0
     __locals_bitmap0 = 0
     r1 = x != 0
@@ -665,7 +665,7 @@ L4:
 L5:
     return y
 L6:
-    r6 = <error> :: int64
+    r6 = <error> :: i64
     return r6
 
 [case testExceptionWithFloatAttribute]
diff --git a/mypyc/test-data/irbuild-any.test b/mypyc/test-data/irbuild-any.test
index 8274e3d5c6190..98f3dae9ee881 100644
--- a/mypyc/test-data/irbuild-any.test
+++ b/mypyc/test-data/irbuild-any.test
@@ -51,7 +51,7 @@ def f(a, n, c):
     r5 :: int
     r6 :: str
     r7 :: object
-    r8 :: int32
+    r8 :: i32
     r9 :: bit
 L0:
     r0 = box(int, n)
@@ -99,10 +99,10 @@ def f2(a, n, l):
     n :: int
     l :: list
     r0, r1, r2, r3, r4 :: object
-    r5 :: int32
+    r5 :: i32
     r6 :: bit
     r7 :: object
-    r8 :: int32
+    r8 :: i32
     r9, r10 :: bit
     r11 :: list
     r12 :: object
diff --git a/mypyc/test-data/irbuild-basic.test b/mypyc/test-data/irbuild-basic.test
index 556e0a4bbc50f..33fc8cfaa83b7 100644
--- a/mypyc/test-data/irbuild-basic.test
+++ b/mypyc/test-data/irbuild-basic.test
@@ -713,7 +713,7 @@ def __top_level__():
     r18 :: str
     r19 :: dict
     r20 :: str
-    r21 :: int32
+    r21 :: i32
     r22 :: bit
     r23 :: object_ptr
     r24 :: object_ptr[1]
@@ -1146,7 +1146,7 @@ def f(x: Any, y: Any, z: Any) -> None:
 [out]
 def f(x, y, z):
     x, y, z :: object
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
 L0:
     r0 = PyObject_SetItem(x, y, z)
@@ -1425,13 +1425,13 @@ def lst(x: List[int]) -> int:
 [out]
 def obj(x):
     x :: object
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
     r2 :: bool
 L0:
     r0 = PyObject_IsTrue(x)
     r1 = r0 >= 0 :: signed
-    r2 = truncate r0: int32 to builtins.bool
+    r2 = truncate r0: i32 to builtins.bool
     if r2 goto L1 else goto L2 :: bool
 L1:
     return 2
@@ -1533,7 +1533,7 @@ def opt_o(x):
     r0 :: object
     r1 :: bit
     r2 :: object
-    r3 :: int32
+    r3 :: i32
     r4 :: bit
     r5 :: bool
 L0:
@@ -1544,7 +1544,7 @@ L1:
     r2 = cast(object, x)
     r3 = PyObject_IsTrue(r2)
     r4 = r3 >= 0 :: signed
-    r5 = truncate r3: int32 to builtins.bool
+    r5 = truncate r3: i32 to builtins.bool
     if r5 goto L2 else goto L3 :: bool
 L2:
     return 2
@@ -1616,7 +1616,7 @@ def __top_level__():
     r5 :: dict
     r6 :: str
     r7 :: object
-    r8 :: int32
+    r8 :: i32
     r9 :: bit
     r10 :: dict
     r11 :: str
@@ -1731,7 +1731,7 @@ def main() -> None:
 def foo(x):
     x :: union[int, str]
     r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3 :: bool
     r4 :: __main__.B
@@ -1740,7 +1740,7 @@ L0:
     r0 = load_address PyLong_Type
     r1 = PyObject_IsInstance(x, r0)
     r2 = r1 >= 0 :: signed
-    r3 = truncate r1: int32 to builtins.bool
+    r3 = truncate r1: i32 to builtins.bool
     if r3 goto L1 else goto L2 :: bool
 L1:
     r4 = B()
@@ -1903,7 +1903,7 @@ def g():
     r8 :: str
     r9 :: object
     r10 :: dict
-    r11 :: int32
+    r11 :: i32
     r12 :: bit
     r13 :: tuple
     r14 :: object
@@ -1933,7 +1933,7 @@ def h():
     r6 :: str
     r7 :: object
     r8 :: dict
-    r9 :: int32
+    r9 :: i32
     r10 :: bit
     r11 :: object
     r12 :: tuple
@@ -2062,7 +2062,7 @@ def f():
     r26, r27 :: bit
     r28 :: int
     r29 :: object
-    r30 :: int32
+    r30 :: i32
     r31 :: bit
     r32 :: short_int
 L0:
@@ -2161,7 +2161,7 @@ def f():
     r26, r27 :: bit
     r28 :: int
     r29, r30 :: object
-    r31 :: int32
+    r31 :: i32
     r32 :: bit
     r33 :: short_int
 L0:
@@ -2430,7 +2430,7 @@ def __top_level__():
     r22, r23 :: object
     r24 :: dict
     r25 :: str
-    r26 :: int32
+    r26 :: i32
     r27 :: bit
     r28 :: str
     r29 :: dict
@@ -2439,14 +2439,14 @@ def __top_level__():
     r34 :: tuple
     r35 :: dict
     r36 :: str
-    r37 :: int32
+    r37 :: i32
     r38 :: bit
     r39 :: dict
     r40 :: str
     r41, r42, r43 :: object
     r44 :: dict
     r45 :: str
-    r46 :: int32
+    r46 :: i32
     r47 :: bit
     r48 :: str
     r49 :: dict
@@ -2457,14 +2457,14 @@ def __top_level__():
     r54, r55 :: object
     r56 :: dict
     r57 :: str
-    r58 :: int32
+    r58 :: i32
     r59 :: bit
     r60 :: list
     r61, r62, r63 :: object
     r64, r65, r66, r67 :: ptr
     r68 :: dict
     r69 :: str
-    r70 :: int32
+    r70 :: i32
     r71 :: bit
 L0:
     r0 = builtins :: module
@@ -2632,7 +2632,7 @@ def A.__ne__(__mypyc_self__, rhs):
     __mypyc_self__ :: __main__.A
     rhs, r0, r1 :: object
     r2 :: bit
-    r3 :: int32
+    r3 :: i32
     r4 :: bit
     r5 :: bool
     r6 :: object
@@ -2644,7 +2644,7 @@ L0:
 L1:
     r3 = PyObject_Not(r0)
     r4 = r3 >= 0 :: signed
-    r5 = truncate r3: int32 to builtins.bool
+    r5 = truncate r3: i32 to builtins.bool
     r6 = box(bool, r5)
     return r6
 L2:
@@ -2836,7 +2836,7 @@ def c():
     r11 :: bool
     r12 :: dict
     r13 :: str
-    r14 :: int32
+    r14 :: i32
     r15 :: bit
     r16 :: str
     r17 :: object
@@ -2886,7 +2886,7 @@ def __top_level__():
     r18, r19 :: object
     r20 :: dict
     r21 :: str
-    r22 :: int32
+    r22 :: i32
     r23 :: bit
 L0:
     r0 = builtins :: module
@@ -3157,7 +3157,7 @@ def lol(x: Any):
 def lol(x):
     x :: object
     r0, r1 :: str
-    r2 :: int32
+    r2 :: i32
     r3 :: bit
     r4 :: object
 L0:
@@ -3462,13 +3462,13 @@ def f(x: object) -> bool:
 [out]
 def f(x):
     x :: object
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
     r2 :: bool
 L0:
     r0 = PyObject_IsTrue(x)
     r1 = r0 >= 0 :: signed
-    r2 = truncate r0: int32 to builtins.bool
+    r2 = truncate r0: i32 to builtins.bool
     return r2
 
 [case testLocalImports]
@@ -3493,7 +3493,7 @@ def root():
     r7 :: dict
     r8 :: str
     r9 :: object
-    r10 :: int32
+    r10 :: i32
     r11 :: bit
     r12 :: dict
     r13, r14 :: object
@@ -3504,7 +3504,7 @@ def root():
     r19 :: dict
     r20 :: str
     r21 :: object
-    r22 :: int32
+    r22 :: i32
     r23 :: bit
 L0:
     r0 = __main__.globals :: static
@@ -3550,7 +3550,7 @@ def submodule():
     r7 :: dict
     r8 :: str
     r9 :: object
-    r10 :: int32
+    r10 :: i32
     r11 :: bit
     r12 :: dict
     r13 :: str
@@ -3589,14 +3589,14 @@ def f(x: object) -> bool:
 [out]
 def f(x):
     x, r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3 :: bool
 L0:
     r0 = load_address PyBool_Type
     r1 = PyObject_IsInstance(x, r0)
     r2 = r1 >= 0 :: signed
-    r3 = truncate r1: int32 to builtins.bool
+    r3 = truncate r1: i32 to builtins.bool
     return r3
 
 [case testRangeObject]
diff --git a/mypyc/test-data/irbuild-bool.test b/mypyc/test-data/irbuild-bool.test
index 9257d8d63f7eb..731d393d69ab1 100644
--- a/mypyc/test-data/irbuild-bool.test
+++ b/mypyc/test-data/irbuild-bool.test
@@ -29,18 +29,18 @@ L0:
     return r0
 def bool_to_i64(b):
     b :: bool
-    r0 :: int64
+    r0 :: i64
 L0:
-    r0 = extend b: builtins.bool to int64
+    r0 = extend b: builtins.bool to i64
     return r0
 def i64_to_bool(n):
-    n :: int64
+    n :: i64
     r0 :: bit
 L0:
     r0 = n != 0
     return r0
 def bit_to_int(n1, n2):
-    n1, n2 :: int64
+    n1, n2 :: i64
     r0 :: bit
     r1 :: bool
     r2 :: int
@@ -50,12 +50,12 @@ L0:
     r2 = extend r1: builtins.bool to builtins.int
     return r2
 def bit_to_i64(n1, n2):
-    n1, n2 :: int64
+    n1, n2 :: i64
     r0 :: bit
-    r1 :: int64
+    r1 :: i64
 L0:
     r0 = n1 == n2
-    r1 = extend r0: bit to int64
+    r1 = extend r0: bit to i64
     return r1
 
 [case testConversionToBool]
@@ -100,13 +100,13 @@ L0:
     return r3
 def always_truthy_instance_to_bool(o):
     o :: __main__.C
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
     r2 :: bool
 L0:
     r0 = PyObject_IsTrue(o)
     r1 = r0 >= 0 :: signed
-    r2 = truncate r0: int32 to builtins.bool
+    r2 = truncate r0: i32 to builtins.bool
     return r2
 def instance_to_bool(o):
     o :: __main__.D
@@ -236,20 +236,20 @@ L0:
     r2 = r1 == y
     return r2
 def neq1(x, y):
-    x :: int64
+    x :: i64
     y :: bool
-    r0 :: int64
+    r0 :: i64
     r1 :: bit
 L0:
-    r0 = extend y: builtins.bool to int64
+    r0 = extend y: builtins.bool to i64
     r1 = x != r0
     return r1
 def neq2(x, y):
     x :: bool
-    y, r0 :: int64
+    y, r0 :: i64
     r1 :: bit
 L0:
-    r0 = extend x: builtins.bool to int64
+    r0 = extend x: builtins.bool to i64
     r1 = r0 != y
     return r1
 
@@ -327,19 +327,19 @@ L3:
     return r8
 def gt1(x, y):
     x :: bool
-    y, r0 :: int64
+    y, r0 :: i64
     r1 :: bit
 L0:
-    r0 = extend x: builtins.bool to int64
+    r0 = extend x: builtins.bool to i64
     r1 = r0 < y :: signed
     return r1
 def gt2(x, y):
-    x :: int64
+    x :: i64
     y :: bool
-    r0 :: int64
+    r0 :: i64
     r1 :: bit
 L0:
-    r0 = extend y: builtins.bool to int64
+    r0 = extend y: builtins.bool to i64
     r1 = x < r0 :: signed
     return r1
 
@@ -386,11 +386,11 @@ L0:
     r2 = CPyTagged_Invert(r1)
     return r2
 def mixed_bitand(x, y):
-    x :: int64
+    x :: i64
     y :: bool
-    r0, r1 :: int64
+    r0, r1 :: i64
 L0:
-    r0 = extend y: builtins.bool to int64
+    r0 = extend y: builtins.bool to i64
     r1 = x & r0
     return r1
 
diff --git a/mypyc/test-data/irbuild-bytes.test b/mypyc/test-data/irbuild-bytes.test
index f13a1a956580e..8e97a7f4a5690 100644
--- a/mypyc/test-data/irbuild-bytes.test
+++ b/mypyc/test-data/irbuild-bytes.test
@@ -71,7 +71,7 @@ def neq(x: bytes, y: bytes) -> bool:
 [out]
 def eq(x, y):
     x, y :: bytes
-    r0 :: int32
+    r0 :: i32
     r1, r2 :: bit
 L0:
     r0 = CPyBytes_Compare(x, y)
@@ -80,7 +80,7 @@ L0:
     return r2
 def neq(x, y):
     x, y :: bytes
-    r0 :: int32
+    r0 :: i32
     r1, r2 :: bit
 L0:
     r0 = CPyBytes_Compare(x, y)
diff --git a/mypyc/test-data/irbuild-classes.test b/mypyc/test-data/irbuild-classes.test
index 0a7076e5f0ad2..55e55dbf3286c 100644
--- a/mypyc/test-data/irbuild-classes.test
+++ b/mypyc/test-data/irbuild-classes.test
@@ -213,7 +213,7 @@ def __top_level__():
     r16, r17 :: object
     r18 :: dict
     r19 :: str
-    r20 :: int32
+    r20 :: i32
     r21 :: bit
     r22 :: object
     r23 :: str
@@ -221,22 +221,22 @@ def __top_level__():
     r26 :: bool
     r27 :: str
     r28 :: tuple
-    r29 :: int32
+    r29 :: i32
     r30 :: bit
     r31 :: dict
     r32 :: str
-    r33 :: int32
+    r33 :: i32
     r34 :: bit
     r35 :: object
     r36 :: str
     r37, r38 :: object
     r39 :: str
     r40 :: tuple
-    r41 :: int32
+    r41 :: i32
     r42 :: bit
     r43 :: dict
     r44 :: str
-    r45 :: int32
+    r45 :: i32
     r46 :: bit
     r47, r48 :: object
     r49 :: dict
@@ -251,11 +251,11 @@ def __top_level__():
     r60 :: bool
     r61, r62 :: str
     r63 :: tuple
-    r64 :: int32
+    r64 :: i32
     r65 :: bit
     r66 :: dict
     r67 :: str
-    r68 :: int32
+    r68 :: i32
     r69 :: bit
 L0:
     r0 = builtins :: module
@@ -837,7 +837,7 @@ def Base.__ne__(__mypyc_self__, rhs):
     __mypyc_self__ :: __main__.Base
     rhs, r0, r1 :: object
     r2 :: bit
-    r3 :: int32
+    r3 :: i32
     r4 :: bit
     r5 :: bool
     r6 :: object
@@ -849,7 +849,7 @@ L0:
 L1:
     r3 = PyObject_Not(r0)
     r4 = r3 >= 0 :: signed
-    r5 = truncate r3: int32 to builtins.bool
+    r5 = truncate r3: i32 to builtins.bool
     r6 = box(bool, r5)
     return r6
 L2:
@@ -957,7 +957,7 @@ def Derived.__ne__(__mypyc_self__, rhs):
     __mypyc_self__ :: __main__.Derived
     rhs, r0, r1 :: object
     r2 :: bit
-    r3 :: int32
+    r3 :: i32
     r4 :: bit
     r5 :: bool
     r6 :: object
@@ -969,7 +969,7 @@ L0:
 L1:
     r3 = PyObject_Not(r0)
     r4 = r3 >= 0 :: signed
-    r5 = truncate r3: int32 to builtins.bool
+    r5 = truncate r3: i32 to builtins.bool
     r6 = box(bool, r5)
     return r6
 L2:
@@ -1029,7 +1029,7 @@ def foo(x: WelpDict) -> None:
 [out]
 def foo(x):
     x :: dict
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
 L0:
     r0 = CPyDict_Update(x, x)
diff --git a/mypyc/test-data/irbuild-dict.test b/mypyc/test-data/irbuild-dict.test
index 362031b84e765..1a84f3fe3098b 100644
--- a/mypyc/test-data/irbuild-dict.test
+++ b/mypyc/test-data/irbuild-dict.test
@@ -21,7 +21,7 @@ def f(d: Dict[int, bool]) -> None:
 def f(d):
     d :: dict
     r0, r1 :: object
-    r2 :: int32
+    r2 :: i32
     r3 :: bit
 L0:
     r0 = object 0
@@ -83,14 +83,14 @@ def f(d: Dict[int, int]) -> bool:
 def f(d):
     d :: dict
     r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3 :: bool
 L0:
     r0 = object 4
     r1 = PyDict_Contains(d, r0)
     r2 = r1 >= 0 :: signed
-    r3 = truncate r1: int32 to builtins.bool
+    r3 = truncate r1: i32 to builtins.bool
     if r3 goto L1 else goto L2 :: bool
 L1:
     return 1
@@ -110,14 +110,14 @@ def f(d: Dict[int, int]) -> bool:
 def f(d):
     d :: dict
     r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3, r4 :: bool
 L0:
     r0 = object 4
     r1 = PyDict_Contains(d, r0)
     r2 = r1 >= 0 :: signed
-    r3 = truncate r1: int32 to builtins.bool
+    r3 = truncate r1: i32 to builtins.bool
     r4 = r3 ^ 1
     if r4 goto L1 else goto L2 :: bool
 L1:
@@ -134,7 +134,7 @@ def f(a: Dict[int, int], b: Dict[int, int]) -> None:
 [out]
 def f(a, b):
     a, b :: dict
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
 L0:
     r0 = CPyDict_Update(a, b)
@@ -160,7 +160,7 @@ def increment(d):
     r7 :: object
     r8, k :: str
     r9, r10, r11 :: object
-    r12 :: int32
+    r12 :: i32
     r13, r14, r15 :: bit
 L0:
     r0 = 0
@@ -201,10 +201,10 @@ def f(x, y):
     r0 :: str
     r1 :: object
     r2 :: dict
-    r3 :: int32
+    r3 :: i32
     r4 :: bit
     r5 :: object
-    r6 :: int32
+    r6 :: i32
     r7 :: bit
 L0:
     r0 = 'z'
@@ -252,7 +252,7 @@ def print_dict_methods(d1, d2):
     r7 :: object
     r8, v :: int
     r9 :: object
-    r10 :: int32
+    r10 :: i32
     r11 :: bit
     r12 :: bool
     r13, r14 :: bit
@@ -266,7 +266,7 @@ def print_dict_methods(d1, d2):
     r22, r23 :: object
     r24, r25, k :: int
     r26, r27, r28, r29, r30 :: object
-    r31 :: int32
+    r31 :: i32
     r32, r33, r34 :: bit
 L0:
     r0 = 0
@@ -286,7 +286,7 @@ L2:
     r9 = box(int, v)
     r10 = PyDict_Contains(d2, r9)
     r11 = r10 >= 0 :: signed
-    r12 = truncate r10: int32 to builtins.bool
+    r12 = truncate r10: i32 to builtins.bool
     if r12 goto L3 else goto L4 :: bool
 L3:
     return 1
@@ -345,7 +345,7 @@ def union_of_dicts(d):
     r12, r13 :: object
     r14 :: int
     r15 :: object
-    r16 :: int32
+    r16 :: i32
     r17, r18, r19 :: bit
 L0:
     r0 = PyDict_New()
@@ -393,7 +393,7 @@ def typeddict(d):
     r9, k :: str
     v :: object
     r10 :: str
-    r11 :: int32
+    r11 :: i32
     r12 :: bit
     r13 :: object
     r14, r15, r16 :: bit
diff --git a/mypyc/test-data/irbuild-dunders.test b/mypyc/test-data/irbuild-dunders.test
index 3c140d927c0f9..b50b6eeae1628 100644
--- a/mypyc/test-data/irbuild-dunders.test
+++ b/mypyc/test-data/irbuild-dunders.test
@@ -103,14 +103,14 @@ L0:
 def h(d):
     d :: __main__.D
     r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3, r4 :: bool
 L0:
     r0 = d.__contains__(14)
     r1 = PyObject_IsTrue(r0)
     r2 = r1 >= 0 :: signed
-    r3 = truncate r1: int32 to builtins.bool
+    r3 = truncate r1: i32 to builtins.bool
     r4 = r3 ^ 1
     return r4
 
diff --git a/mypyc/test-data/irbuild-float.test b/mypyc/test-data/irbuild-float.test
index e3a60852574b8..35e2eff62b863 100644
--- a/mypyc/test-data/irbuild-float.test
+++ b/mypyc/test-data/irbuild-float.test
@@ -241,7 +241,7 @@ def f(x: float = 1.5) -> float:
 [out]
 def f(x, __bitmap):
     x :: float
-    __bitmap, r0 :: uint32
+    __bitmap, r0 :: u32
     r1 :: bit
 L0:
     r0 = __bitmap & 1
diff --git a/mypyc/test-data/irbuild-generics.test b/mypyc/test-data/irbuild-generics.test
index fe4a949927174..35920889e5962 100644
--- a/mypyc/test-data/irbuild-generics.test
+++ b/mypyc/test-data/irbuild-generics.test
@@ -132,7 +132,7 @@ def f(x: T, y: T) -> T:
 [out]
 def f(x, y):
     x, y, r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3 :: bool
     r4 :: object
@@ -140,7 +140,7 @@ L0:
     r0 = PyObject_RichCompare(y, x, 4)
     r1 = PyObject_IsTrue(r0)
     r2 = r1 >= 0 :: signed
-    r3 = truncate r1: int32 to builtins.bool
+    r3 = truncate r1: i32 to builtins.bool
     if r3 goto L1 else goto L2 :: bool
 L1:
     r4 = y
diff --git a/mypyc/test-data/irbuild-glue-methods.test b/mypyc/test-data/irbuild-glue-methods.test
index 6d749bf5dd848..3012c79586f25 100644
--- a/mypyc/test-data/irbuild-glue-methods.test
+++ b/mypyc/test-data/irbuild-glue-methods.test
@@ -343,8 +343,8 @@ L0:
     return 1
 def D.f(self, x, __bitmap):
     self :: __main__.D
-    x :: int64
-    __bitmap, r0 :: uint32
+    x :: i64
+    __bitmap, r0 :: u32
     r1 :: bit
 L0:
     r0 = __bitmap & 1
@@ -371,8 +371,8 @@ class D(C):
 [out]
 def C.f(self, x, __bitmap):
     self :: __main__.C
-    x :: int64
-    __bitmap, r0 :: uint32
+    x :: i64
+    __bitmap, r0 :: u32
     r1 :: bit
 L0:
     r0 = __bitmap & 1
@@ -384,10 +384,10 @@ L2:
     return 1
 def D.f(self, x, y, __bitmap):
     self :: __main__.D
-    x, y :: int64
-    __bitmap, r0 :: uint32
+    x, y :: i64
+    __bitmap, r0 :: u32
     r1 :: bit
-    r2 :: uint32
+    r2 :: u32
     r3 :: bit
 L0:
     r0 = __bitmap & 1
@@ -405,8 +405,8 @@ L4:
     return 1
 def D.f__C_glue(self, x, __bitmap):
     self :: __main__.D
-    x :: int64
-    __bitmap :: uint32
+    x :: i64
+    __bitmap :: u32
     r0 :: None
 L0:
     r0 = D.f(self, x, 0, __bitmap)
@@ -432,6 +432,6 @@ class E:
 class EE(E):
     def f(self, x: int) -> None: pass  # Line 18
 [out]
-main:7: error: An argument with type "int64" cannot be given a default value in a method override
-main:13: error: Incompatible argument type "int64" (base class has type "int")
-main:18: error: Incompatible argument type "int" (base class has type "int64")
+main:7: error: An argument with type "i64" cannot be given a default value in a method override
+main:13: error: Incompatible argument type "i64" (base class has type "int")
+main:18: error: Incompatible argument type "int" (base class has type "i64")
diff --git a/mypyc/test-data/irbuild-i16.test b/mypyc/test-data/irbuild-i16.test
index 0f34ea53818d5..a03c9df2c6ac4 100644
--- a/mypyc/test-data/irbuild-i16.test
+++ b/mypyc/test-data/irbuild-i16.test
@@ -20,7 +20,7 @@ def compare(x: i16, y: i16) -> None:
     f = -5 < x
 [out]
 def add_op(x, y):
-    x, y, r0, r1, r2, r3, r4 :: int16
+    x, y, r0, r1, r2, r3, r4 :: i16
 L0:
     r0 = y + x
     x = r0
@@ -34,7 +34,7 @@ L0:
     x = r4
     return x
 def compare(x, y):
-    x, y :: int16
+    x, y :: i16
     r0 :: bit
     a :: bool
     r1 :: bit
@@ -72,7 +72,7 @@ def unary(x: i16) -> i16:
     return y
 [out]
 def unary(x):
-    x, r0, y, r1 :: int16
+    x, r0, y, r1 :: i16
 L0:
     r0 = 0 - x
     y = r0
@@ -90,15 +90,15 @@ def div_by_constant(x: i16) -> i16:
     return x
 [out]
 def div_by_constant(x):
-    x, r0, r1 :: int16
+    x, r0, r1 :: i16
     r2, r3, r4 :: bit
-    r5 :: int16
+    r5 :: i16
     r6 :: bit
-    r7, r8, r9 :: int16
+    r7, r8, r9 :: i16
     r10, r11, r12 :: bit
-    r13 :: int16
+    r13 :: i16
     r14 :: bit
-    r15 :: int16
+    r15 :: i16
 L0:
     r0 = x / 5
     r1 = r0
@@ -141,11 +141,11 @@ def mod_by_constant(x: i16) -> i16:
     return x
 [out]
 def mod_by_constant(x):
-    x, r0, r1 :: int16
+    x, r0, r1 :: i16
     r2, r3, r4, r5 :: bit
-    r6, r7, r8 :: int16
+    r6, r7, r8 :: i16
     r9, r10, r11, r12 :: bit
-    r13 :: int16
+    r13 :: i16
 L0:
     r0 = x % 5
     r1 = r0
@@ -185,13 +185,27 @@ def divmod(x: i16, y: i16) -> i16:
     return a % y
 [out]
 def divmod(x, y):
-    x, y, r0, a, r1 :: int16
+    x, y, r0, a, r1 :: i16
 L0:
     r0 = CPyInt16_Divide(x, y)
     a = r0
     r1 = CPyInt16_Remainder(a, y)
     return r1
 
+[case testI16BinaryOperationWithOutOfRangeOperand]
+from mypy_extensions import i16
+
+def out_of_range(x: i16) -> None:
+    x + (-32769)
+    (-32770) + x
+    x * 32768
+    x + 32767  # OK
+    (-32768) + x   # OK
+[out]
+main:4: error: Value -32769 is out of range for "i16"
+main:5: error: Value -32770 is out of range for "i16"
+main:6: error: Value 32768 is out of range for "i16"
+
 [case testI16BoxAndUnbox]
 from typing import Any
 from mypy_extensions import i16
@@ -202,12 +216,12 @@ def f(x: Any) -> Any:
 [out]
 def f(x):
     x :: object
-    r0, y :: int16
+    r0, y :: i16
     r1 :: object
 L0:
-    r0 = unbox(int16, x)
+    r0 = unbox(i16, x)
     y = r0
-    r1 = box(int16, y)
+    r1 = box(i16, y)
     return r1
 
 [case testI16MixedCompare1]
@@ -217,11 +231,11 @@ def f(x: int, y: i16) -> bool:
 [out]
 def f(x, y):
     x :: int
-    y :: int16
+    y :: i16
     r0 :: native_int
     r1, r2, r3 :: bit
     r4 :: native_int
-    r5, r6 :: int16
+    r5, r6 :: i16
     r7 :: bit
 L0:
     r0 = x & 1
@@ -235,7 +249,7 @@ L2:
     if r3 goto L3 else goto L4 :: bool
 L3:
     r4 = x >> 1
-    r5 = truncate r4: native_int to int16
+    r5 = truncate r4: native_int to i16
     r6 = r5
     goto L5
 L4:
@@ -251,12 +265,12 @@ def f(x: i16, y: int) -> bool:
     return x == y
 [out]
 def f(x, y):
-    x :: int16
+    x :: i16
     y :: int
     r0 :: native_int
     r1, r2, r3 :: bit
     r4 :: native_int
-    r5, r6 :: int16
+    r5, r6 :: i16
     r7 :: bit
 L0:
     r0 = y & 1
@@ -270,7 +284,7 @@ L2:
     if r3 goto L3 else goto L4 :: bool
 L3:
     r4 = y >> 1
-    r5 = truncate r4: native_int to int16
+    r5 = truncate r4: native_int to i16
     r6 = r5
     goto L5
 L4:
@@ -287,11 +301,11 @@ def i16_to_int(a: i16) -> int:
     return a
 [out]
 def i16_to_int(a):
-    a :: int16
+    a :: i16
     r0 :: native_int
     r1 :: int
 L0:
-    r0 = extend signed a: int16 to native_int
+    r0 = extend signed a: i16 to native_int
     r1 = r0 << 1
     return r1
 
@@ -303,12 +317,12 @@ def f(a: i16) -> None:
     x += a
 [out]
 def f(a):
-    a :: int16
+    a :: i16
     x :: int
     r0 :: native_int
     r1, r2, r3 :: bit
     r4 :: native_int
-    r5, r6, r7 :: int16
+    r5, r6, r7 :: i16
     r8 :: native_int
     r9 :: int
 L0:
@@ -324,7 +338,7 @@ L2:
     if r3 goto L3 else goto L4 :: bool
 L3:
     r4 = x >> 1
-    r5 = truncate r4: native_int to int16
+    r5 = truncate r4: native_int to i16
     r6 = r5
     goto L5
 L4:
@@ -332,7 +346,7 @@ L4:
     unreachable
 L5:
     r7 = r6 + a
-    r8 = extend signed r7: int16 to native_int
+    r8 = extend signed r7: i16 to native_int
     r9 = r8 << 1
     x = r9
     return 1
@@ -346,7 +360,7 @@ def f() -> None:
     z: i16 = 5 + 7
 [out]
 def f():
-    x, y, z :: int16
+    x, y, z :: i16
 L0:
     x = 0
     y = -127
@@ -366,20 +380,20 @@ def from_i64(x: i64) -> i16:
     return i16(x)
 [out]
 def from_i16(x):
-    x :: int16
+    x :: i16
 L0:
     return x
 def from_i32(x):
-    x :: int32
-    r0 :: int16
+    x :: i32
+    r0 :: i16
 L0:
-    r0 = truncate x: int32 to int16
+    r0 = truncate x: i32 to i16
     return r0
 def from_i64(x):
-    x :: int64
-    r0 :: int16
+    x :: i64
+    r0 :: i16
 L0:
-    r0 = truncate x: int64 to int16
+    r0 = truncate x: i64 to i16
     return r0
 
 [case testI16ExplicitConversionFromInt]
@@ -393,7 +407,7 @@ def f(x):
     r0 :: native_int
     r1, r2, r3 :: bit
     r4 :: native_int
-    r5, r6 :: int16
+    r5, r6 :: i16
 L0:
     r0 = x & 1
     r1 = r0 == 0
@@ -406,7 +420,7 @@ L2:
     if r3 goto L3 else goto L4 :: bool
 L3:
     r4 = x >> 1
-    r5 = truncate r4: native_int to int16
+    r5 = truncate r4: native_int to i16
     r6 = r5
     goto L5
 L4:
@@ -422,13 +436,21 @@ def f() -> None:
     x = i16(0)
     y = i16(11)
     z = i16(-3)
+    a = i16(32767)
+    b = i16(32768)  # Truncate
+    c = i16(-32768)
+    d = i16(-32769)  # Truncate
 [out]
 def f():
-    x, y, z :: int16
+    x, y, z, a, b, c, d :: i16
 L0:
     x = 0
     y = 11
     z = -3
+    a = 32767
+    b = -32768
+    c = -32768
+    d = 32767
     return 1
 
 [case testI16ExplicitConversionFromVariousTypes]
@@ -452,17 +474,17 @@ def float_to_i16(x: float) -> i16:
 [out]
 def bool_to_i16(b):
     b :: bool
-    r0 :: int16
+    r0 :: i16
 L0:
-    r0 = extend b: builtins.bool to int16
+    r0 = extend b: builtins.bool to i16
     return r0
 def str_to_i16(s):
     s :: str
     r0 :: object
-    r1 :: int16
+    r1 :: i16
 L0:
     r0 = CPyLong_FromStr(s)
-    r1 = unbox(int16, r0)
+    r1 = unbox(i16, r0)
     return r1
 def C.__int__(self):
     self :: __main__.C
@@ -470,7 +492,7 @@ L0:
     return 5
 def instance_to_i16(c):
     c :: __main__.C
-    r0 :: int16
+    r0 :: i16
 L0:
     r0 = c.__int__()
     return r0
@@ -480,7 +502,7 @@ def float_to_i16(x):
     r1 :: native_int
     r2, r3, r4 :: bit
     r5 :: native_int
-    r6, r7 :: int16
+    r6, r7 :: i16
 L0:
     r0 = CPyTagged_FromFloat(x)
     r1 = r0 & 1
@@ -494,7 +516,7 @@ L2:
     if r4 goto L3 else goto L4 :: bool
 L3:
     r5 = r0 >> 1
-    r6 = truncate r5: native_int to int16
+    r6 = truncate r5: native_int to i16
     r7 = r6
     goto L5
 L4:
diff --git a/mypyc/test-data/irbuild-i32.test b/mypyc/test-data/irbuild-i32.test
index 4b69fa3a6bbb0..7dcb722ec9067 100644
--- a/mypyc/test-data/irbuild-i32.test
+++ b/mypyc/test-data/irbuild-i32.test
@@ -20,7 +20,7 @@ def compare(x: i32, y: i32) -> None:
     f = -5 < x
 [out]
 def add_op(x, y):
-    x, y, r0, r1, r2, r3, r4 :: int32
+    x, y, r0, r1, r2, r3, r4 :: i32
 L0:
     r0 = y + x
     x = r0
@@ -34,7 +34,7 @@ L0:
     x = r4
     return x
 def compare(x, y):
-    x, y :: int32
+    x, y :: i32
     r0 :: bit
     a :: bool
     r1 :: bit
@@ -72,7 +72,7 @@ def unary(x: i32) -> i32:
     return y
 [out]
 def unary(x):
-    x, r0, y, r1 :: int32
+    x, r0, y, r1 :: i32
 L0:
     r0 = 0 - x
     y = r0
@@ -90,15 +90,15 @@ def div_by_constant(x: i32) -> i32:
     return x
 [out]
 def div_by_constant(x):
-    x, r0, r1 :: int32
+    x, r0, r1 :: i32
     r2, r3, r4 :: bit
-    r5 :: int32
+    r5 :: i32
     r6 :: bit
-    r7, r8, r9 :: int32
+    r7, r8, r9 :: i32
     r10, r11, r12 :: bit
-    r13 :: int32
+    r13 :: i32
     r14 :: bit
-    r15 :: int32
+    r15 :: i32
 L0:
     r0 = x / 5
     r1 = r0
@@ -141,11 +141,11 @@ def mod_by_constant(x: i32) -> i32:
     return x
 [out]
 def mod_by_constant(x):
-    x, r0, r1 :: int32
+    x, r0, r1 :: i32
     r2, r3, r4, r5 :: bit
-    r6, r7, r8 :: int32
+    r6, r7, r8 :: i32
     r9, r10, r11, r12 :: bit
-    r13 :: int32
+    r13 :: i32
 L0:
     r0 = x % 5
     r1 = r0
@@ -185,7 +185,7 @@ def divmod(x: i32, y: i32) -> i32:
     return a % y
 [out]
 def divmod(x, y):
-    x, y, r0, a, r1 :: int32
+    x, y, r0, a, r1 :: i32
 L0:
     r0 = CPyInt32_Divide(x, y)
     a = r0
@@ -202,12 +202,12 @@ def f(x: Any) -> Any:
 [out]
 def f(x):
     x :: object
-    r0, y :: int32
+    r0, y :: i32
     r1 :: object
 L0:
-    r0 = unbox(int32, x)
+    r0 = unbox(i32, x)
     y = r0
-    r1 = box(int32, y)
+    r1 = box(i32, y)
     return r1
 
 [case testI32MixedCompare1_64bit]
@@ -217,11 +217,11 @@ def f(x: int, y: i32) -> bool:
 [out]
 def f(x, y):
     x :: int
-    y :: int32
+    y :: i32
     r0 :: native_int
     r1, r2, r3 :: bit
     r4 :: native_int
-    r5, r6 :: int32
+    r5, r6 :: i32
     r7 :: bit
 L0:
     r0 = x & 1
@@ -235,7 +235,7 @@ L2:
     if r3 goto L3 else goto L4 :: bool
 L3:
     r4 = x >> 1
-    r5 = truncate r4: native_int to int32
+    r5 = truncate r4: native_int to i32
     r6 = r5
     goto L5
 L4:
@@ -251,12 +251,12 @@ def f(x: i32, y: int) -> bool:
     return x == y
 [out]
 def f(x, y):
-    x :: int32
+    x :: i32
     y :: int
     r0 :: native_int
     r1, r2, r3 :: bit
     r4 :: native_int
-    r5, r6 :: int32
+    r5, r6 :: i32
     r7 :: bit
 L0:
     r0 = y & 1
@@ -270,7 +270,7 @@ L2:
     if r3 goto L3 else goto L4 :: bool
 L3:
     r4 = y >> 1
-    r5 = truncate r4: native_int to int32
+    r5 = truncate r4: native_int to i32
     r6 = r5
     goto L5
 L4:
@@ -287,13 +287,13 @@ def f(x: int, y: i32) -> bool:
 [out]
 def f(x, y):
     x :: int
-    y :: int32
+    y :: i32
     r0 :: native_int
     r1 :: bit
-    r2, r3 :: int32
+    r2, r3 :: i32
     r4 :: ptr
     r5 :: c_ptr
-    r6 :: int32
+    r6 :: i32
     r7 :: bit
 L0:
     r0 = x & 1
@@ -320,11 +320,11 @@ def i32_to_int(a: i32) -> int:
     return a
 [out]
 def i32_to_int(a):
-    a :: int32
+    a :: i32
     r0 :: native_int
     r1 :: int
 L0:
-    r0 = extend signed a: int32 to native_int
+    r0 = extend signed a: i32 to native_int
     r1 = r0 << 1
     return r1
 
@@ -335,7 +335,7 @@ def i32_to_int(a: i32) -> int:
     return a
 [out]
 def i32_to_int(a):
-    a :: int32
+    a :: i32
     r0, r1 :: bit
     r2, r3, r4 :: int
 L0:
@@ -362,12 +362,12 @@ def f(a: i32) -> None:
     x += a
 [out]
 def f(a):
-    a :: int32
+    a :: i32
     x :: int
     r0 :: native_int
     r1, r2, r3 :: bit
     r4 :: native_int
-    r5, r6, r7 :: int32
+    r5, r6, r7 :: i32
     r8 :: native_int
     r9 :: int
 L0:
@@ -383,7 +383,7 @@ L2:
     if r3 goto L3 else goto L4 :: bool
 L3:
     r4 = x >> 1
-    r5 = truncate r4: native_int to int32
+    r5 = truncate r4: native_int to i32
     r6 = r5
     goto L5
 L4:
@@ -391,7 +391,7 @@ L4:
     unreachable
 L5:
     r7 = r6 + a
-    r8 = extend signed r7: int32 to native_int
+    r8 = extend signed r7: i32 to native_int
     r9 = r8 << 1
     x = r9
     return 1
@@ -405,7 +405,7 @@ def f() -> None:
     z: i32 = 5 + 7
 [out]
 def f():
-    x, y, z :: int32
+    x, y, z :: i32
 L0:
     x = 0
     y = -127
@@ -425,20 +425,20 @@ def from_i64(x: i64) -> i32:
     return i32(x)
 [out]
 def from_i16(x):
-    x :: int16
-    r0 :: int32
+    x :: i16
+    r0 :: i32
 L0:
-    r0 = extend signed x: int16 to int32
+    r0 = extend signed x: i16 to i32
     return r0
 def from_i32(x):
-    x :: int32
+    x :: i32
 L0:
     return x
 def from_i64(x):
-    x :: int64
-    r0 :: int32
+    x :: i64
+    r0 :: i32
 L0:
-    r0 = truncate x: int64 to int32
+    r0 = truncate x: i64 to i32
     return r0
 
 [case testI32ExplicitConversionFromInt_64bit]
@@ -452,7 +452,7 @@ def f(x):
     r0 :: native_int
     r1, r2, r3 :: bit
     r4 :: native_int
-    r5, r6 :: int32
+    r5, r6 :: i32
 L0:
     r0 = x & 1
     r1 = r0 == 0
@@ -465,7 +465,7 @@ L2:
     if r3 goto L3 else goto L4 :: bool
 L3:
     r4 = x >> 1
-    r5 = truncate r4: native_int to int32
+    r5 = truncate r4: native_int to i32
     r6 = r5
     goto L5
 L4:
@@ -474,20 +474,22 @@ L4:
 L5:
     return r6
 
-[case testI32ExplicitConversionFromLiteral]
+[case testI32ExplicitConversionFromLiteral_64bit]
 from mypy_extensions import i32
 
 def f() -> None:
     x = i32(0)
     y = i32(11)
     z = i32(-3)
+    a = i32(2**31)
 [out]
 def f():
-    x, y, z :: int32
+    x, y, z, a :: i32
 L0:
     x = 0
     y = 11
     z = -3
+    a = -2147483648
     return 1
 
 [case testI32ExplicitConversionFromVariousTypes_64bit]
@@ -511,17 +513,17 @@ def float_to_i32(x: float) -> i32:
 [out]
 def bool_to_i32(b):
     b :: bool
-    r0 :: int32
+    r0 :: i32
 L0:
-    r0 = extend b: builtins.bool to int32
+    r0 = extend b: builtins.bool to i32
     return r0
 def str_to_i32(s):
     s :: str
     r0 :: object
-    r1 :: int32
+    r1 :: i32
 L0:
     r0 = CPyLong_FromStr(s)
-    r1 = unbox(int32, r0)
+    r1 = unbox(i32, r0)
     return r1
 def C.__int__(self):
     self :: __main__.C
@@ -529,7 +531,7 @@ L0:
     return 5
 def instance_to_i32(c):
     c :: __main__.C
-    r0 :: int32
+    r0 :: i32
 L0:
     r0 = c.__int__()
     return r0
@@ -539,7 +541,7 @@ def float_to_i32(x):
     r1 :: native_int
     r2, r3, r4 :: bit
     r5 :: native_int
-    r6, r7 :: int32
+    r6, r7 :: i32
 L0:
     r0 = CPyTagged_FromFloat(x)
     r1 = r0 & 1
@@ -553,7 +555,7 @@ L2:
     if r4 goto L3 else goto L4 :: bool
 L3:
     r5 = r0 >> 1
-    r6 = truncate r5: native_int to int32
+    r6 = truncate r5: native_int to i32
     r7 = r6
     goto L5
 L4:
@@ -573,10 +575,10 @@ def float_to_i32(x):
     r0 :: int
     r1 :: native_int
     r2 :: bit
-    r3, r4 :: int32
+    r3, r4 :: i32
     r5 :: ptr
     r6 :: c_ptr
-    r7 :: int32
+    r7 :: i32
 L0:
     r0 = CPyTagged_FromFloat(x)
     r1 = r0 & 1
diff --git a/mypyc/test-data/irbuild-i64.test b/mypyc/test-data/irbuild-i64.test
index 38561178ddd0a..07f549c9fcc20 100644
--- a/mypyc/test-data/irbuild-i64.test
+++ b/mypyc/test-data/irbuild-i64.test
@@ -7,7 +7,7 @@ def f() -> i64:
     return y
 [out]
 def f():
-    x, y :: int64
+    x, y :: i64
 L0:
     x = 5
     y = x
@@ -40,7 +40,7 @@ def all_comparisons(x: i64) -> int:
     return y
 [out]
 def min(x, y):
-    x, y :: int64
+    x, y :: i64
     r0 :: bit
 L0:
     r0 = x < y :: signed
@@ -52,7 +52,7 @@ L2:
 L3:
     unreachable
 def all_comparisons(x):
-    x :: int64
+    x :: i64
     r0 :: bit
     y :: int
     r1, r2, r3, r4, r5 :: bit
@@ -110,7 +110,7 @@ def f(x: i64, y: i64) -> i64:
     return y - z
 [out]
 def f(x, y):
-    x, y, r0, z, r1 :: int64
+    x, y, r0, z, r1 :: i64
 L0:
     r0 = x + y
     z = r0
@@ -125,7 +125,7 @@ def f() -> i64:
     return -i
 [out]
 def f():
-    i, r0 :: int64
+    i, r0 :: i64
 L0:
     i = -3
     r0 = 0 - i
@@ -140,7 +140,7 @@ def unary(x: i64) -> i64:
     return x
 [out]
 def unary(x):
-    x, r0, y :: int64
+    x, r0, y :: i64
 L0:
     r0 = x ^ -1
     y = r0
@@ -157,12 +157,12 @@ def f(a: Any) -> None:
 [out]
 def f(a):
     a :: object
-    r0, b :: int64
+    r0, b :: i64
     r1 :: object
 L0:
-    r0 = unbox(int64, a)
+    r0 = unbox(i64, a)
     b = r0
-    r1 = box(int64, b)
+    r1 = box(i64, b)
     a = r1
     return 1
 
@@ -177,20 +177,20 @@ def set(a: List[i64], i: i64, x: i64) -> None:
 [out]
 def get(a, i):
     a :: list
-    i :: int64
+    i :: i64
     r0 :: object
-    r1 :: int64
+    r1 :: i64
 L0:
     r0 = CPyList_GetItemInt64(a, i)
-    r1 = unbox(int64, r0)
+    r1 = unbox(i64, r0)
     return r1
 def set(a, i, x):
     a :: list
-    i, x :: int64
+    i, x :: i64
     r0 :: object
     r1 :: bit
 L0:
-    r0 = box(int64, x)
+    r0 = box(i64, x)
     r1 = CPyList_SetItemInt64(a, i, r0)
     return 1
 
@@ -203,7 +203,7 @@ def f() -> i64:
     return 3 - b
 [out]
 def f():
-    a, r0, b, r1 :: int64
+    a, r0, b, r1 :: i64
 L0:
     a = 1
     r0 = a + 2
@@ -222,7 +222,7 @@ def f(a: i64) -> i64:
     return 3
 [out]
 def f(a):
-    a :: int64
+    a :: i64
     r0, r1 :: bit
 L0:
     r0 = a < 3 :: signed
@@ -257,7 +257,7 @@ def others(a: i64, b: i64) -> i64:
     return a
 [out]
 def add(a):
-    a, b, r0, r1 :: int64
+    a, b, r0, r1 :: i64
 L0:
     b = a
     r0 = b + 1
@@ -266,7 +266,7 @@ L0:
     a = r1
     return a
 def others(a, b):
-    a, b, r0, r1, r2, r3, r4, r5, r6 :: int64
+    a, b, r0, r1, r2, r3, r4, r5, r6 :: i64
 L0:
     r0 = a - b
     a = r0
@@ -307,7 +307,7 @@ def unary(a: i64) -> i64:
     return ~a
 [out]
 def forward(a, b):
-    a, b, r0, r1, r2, r3, r4 :: int64
+    a, b, r0, r1, r2, r3, r4 :: i64
 L0:
     r0 = a & 1
     b = r0
@@ -321,7 +321,7 @@ L0:
     b = r4
     return b
 def reverse(a, b):
-    a, b, r0, r1, r2, r3, r4 :: int64
+    a, b, r0, r1, r2, r3, r4 :: i64
 L0:
     r0 = 1 & a
     b = r0
@@ -335,7 +335,7 @@ L0:
     b = r4
     return b
 def unary(a):
-    a, r0 :: int64
+    a, r0 :: i64
 L0:
     r0 = a ^ -1
     return r0
@@ -355,11 +355,11 @@ def divide_by_zero(x: i64) -> i64:
     return x // 0
 [out]
 def constant_divisor(x):
-    x, r0, r1 :: int64
+    x, r0, r1 :: i64
     r2, r3, r4 :: bit
-    r5 :: int64
+    r5 :: i64
     r6 :: bit
-    r7 :: int64
+    r7 :: i64
 L0:
     r0 = x / 7
     r1 = r0
@@ -377,22 +377,22 @@ L2:
 L3:
     return r1
 def variable_divisor(x, y):
-    x, y, r0 :: int64
+    x, y, r0 :: i64
 L0:
     r0 = CPyInt64_Divide(x, y)
     return r0
 def constant_lhs(x):
-    x, r0 :: int64
+    x, r0 :: i64
 L0:
     r0 = CPyInt64_Divide(27, x)
     return r0
 def divide_by_neg_one(x):
-    x, r0 :: int64
+    x, r0 :: i64
 L0:
     r0 = CPyInt64_Divide(x, -1)
     return r0
 def divide_by_zero(x):
-    x, r0 :: int64
+    x, r0 :: i64
 L0:
     r0 = CPyInt64_Divide(x, 0)
     return r0
@@ -410,9 +410,9 @@ def mod_by_zero(x: i64) -> i64:
     return x % 0
 [out]
 def constant_divisor(x):
-    x, r0, r1 :: int64
+    x, r0, r1 :: i64
     r2, r3, r4, r5 :: bit
-    r6 :: int64
+    r6 :: i64
 L0:
     r0 = x % 7
     r1 = r0
@@ -429,17 +429,17 @@ L2:
 L3:
     return r1
 def variable_divisor(x, y):
-    x, y, r0 :: int64
+    x, y, r0 :: i64
 L0:
     r0 = CPyInt64_Remainder(x, y)
     return r0
 def constant_lhs(x):
-    x, r0 :: int64
+    x, r0 :: i64
 L0:
     r0 = CPyInt64_Remainder(27, x)
     return r0
 def mod_by_zero(x):
-    x, r0 :: int64
+    x, r0 :: i64
 L0:
     r0 = CPyInt64_Remainder(x, 0)
     return r0
@@ -455,11 +455,11 @@ def by_variable(x: i64, y: i64) -> i64:
     return x
 [out]
 def by_constant(x):
-    x, r0, r1 :: int64
+    x, r0, r1 :: i64
     r2, r3, r4 :: bit
-    r5 :: int64
+    r5 :: i64
     r6 :: bit
-    r7 :: int64
+    r7 :: i64
 L0:
     r0 = x / 7
     r1 = r0
@@ -478,7 +478,7 @@ L3:
     x = r1
     return x
 def by_variable(x, y):
-    x, y, r0 :: int64
+    x, y, r0 :: i64
 L0:
     r0 = CPyInt64_Divide(x, y)
     x = r0
@@ -495,9 +495,9 @@ def by_variable(x: i64, y: i64) -> i64:
     return x
 [out]
 def by_constant(x):
-    x, r0, r1 :: int64
+    x, r0, r1 :: i64
     r2, r3, r4, r5 :: bit
-    r6 :: int64
+    r6 :: i64
 L0:
     r0 = x % 7
     r1 = r0
@@ -515,7 +515,7 @@ L3:
     x = r1
     return x
 def by_variable(x, y):
-    x, y, r0 :: int64
+    x, y, r0 :: i64
 L0:
     r0 = CPyInt64_Remainder(x, y)
     x = r0
@@ -532,14 +532,14 @@ def f(x: i64) -> None:
         g(n)
 [out]
 def g(a):
-    a :: int64
+    a :: i64
 L0:
     return 1
 def f(x):
-    x, r0, n :: int64
+    x, r0, n :: i64
     r1 :: bit
     r2 :: None
-    r3 :: int64
+    r3 :: i64
 L0:
     r0 = 0
     n = r0
@@ -566,10 +566,10 @@ def int_to_i64(a):
     a :: int
     r0 :: native_int
     r1 :: bit
-    r2, r3 :: int64
+    r2, r3 :: i64
     r4 :: ptr
     r5 :: c_ptr
-    r6 :: int64
+    r6 :: i64
 L0:
     r0 = a & 1
     r1 = r0 == 0
@@ -594,7 +594,7 @@ def i64_to_int(a: i64) -> int:
     return a
 [out]
 def i64_to_int(a):
-    a :: int64
+    a :: i64
     r0, r1 :: bit
     r2, r3, r4 :: int
 L0:
@@ -620,7 +620,7 @@ def i64_to_int(a: i64) -> int:
     return a
 [out]
 def i64_to_int(a):
-    a :: int64
+    a :: i64
     r0, r1 :: bit
     r2, r3 :: int
     r4 :: native_int
@@ -636,7 +636,7 @@ L2:
     r3 = r2
     goto L4
 L3:
-    r4 = truncate a: int64 to native_int
+    r4 = truncate a: i64 to native_int
     r5 = r4 << 1
     r3 = r5
 L4:
@@ -658,23 +658,23 @@ def h() -> i64:
     return x + y + t[0]
 [out]
 def f(x, y):
-    x, y :: int64
-    r0 :: tuple[int64, int64]
+    x, y :: i64
+    r0 :: tuple[i64, i64]
 L0:
     r0 = (x, y)
     return r0
 def g():
     r0 :: tuple[int, int]
-    r1 :: tuple[int64, int64]
+    r1 :: tuple[i64, i64]
 L0:
     r0 = (2, 4)
     r1 = (1, 2)
     return r1
 def h():
-    r0 :: tuple[int64, int64]
-    r1, x, r2, y :: int64
-    r3, t :: tuple[int64, int64]
-    r4, r5, r6 :: int64
+    r0 :: tuple[i64, i64]
+    r1, x, r2, y :: i64
+    r3, t :: tuple[i64, i64]
+    r4, r5, r6 :: i64
 L0:
     r0 = g()
     r1 = r0[0]
@@ -694,14 +694,14 @@ def f(x: i64, y: int) -> i64:
     return x + y
 [out]
 def f(x, y):
-    x :: int64
+    x :: i64
     y :: int
     r0 :: native_int
     r1 :: bit
-    r2, r3 :: int64
+    r2, r3 :: i64
     r4 :: ptr
     r5 :: c_ptr
-    r6, r7 :: int64
+    r6, r7 :: i64
 L0:
     r0 = y & 1
     r1 = r0 == 0
@@ -727,13 +727,13 @@ def f(x: int, y: i64) -> i64:
 [out]
 def f(x, y):
     x :: int
-    y :: int64
+    y :: i64
     r0 :: native_int
     r1 :: bit
-    r2, r3 :: int64
+    r2, r3 :: i64
     r4 :: ptr
     r5 :: c_ptr
-    r6, r7 :: int64
+    r6, r7 :: i64
 L0:
     r0 = x & 1
     r1 = r0 == 0
@@ -760,14 +760,14 @@ def f(y: i64) -> int:
     return x
 [out]
 def f(y):
-    y :: int64
+    y :: i64
     x :: int
     r0 :: native_int
     r1 :: bit
-    r2, r3 :: int64
+    r2, r3 :: i64
     r4 :: ptr
     r5 :: c_ptr
-    r6, r7 :: int64
+    r6, r7 :: i64
     r8, r9 :: bit
     r10, r11, r12 :: int
 L0:
@@ -812,13 +812,13 @@ def f(y: int) -> i64:
 [out]
 def f(y):
     y :: int
-    x :: int64
+    x :: i64
     r0 :: native_int
     r1 :: bit
-    r2, r3 :: int64
+    r2, r3 :: i64
     r4 :: ptr
     r5 :: c_ptr
-    r6, r7 :: int64
+    r6, r7 :: i64
 L0:
     x = 0
     r0 = y & 1
@@ -846,13 +846,13 @@ def f(x: int, y: i64) -> bool:
 [out]
 def f(x, y):
     x :: int
-    y :: int64
+    y :: i64
     r0 :: native_int
     r1 :: bit
-    r2, r3 :: int64
+    r2, r3 :: i64
     r4 :: ptr
     r5 :: c_ptr
-    r6 :: int64
+    r6 :: i64
     r7 :: bit
 L0:
     r0 = x & 1
@@ -878,14 +878,14 @@ def f(x: i64, y: int) -> bool:
     return x == y
 [out]
 def f(x, y):
-    x :: int64
+    x :: i64
     y :: int
     r0 :: native_int
     r1 :: bit
-    r2, r3 :: int64
+    r2, r3 :: i64
     r4 :: ptr
     r5 :: c_ptr
-    r6 :: int64
+    r6 :: i64
     r7 :: bit
 L0:
     r0 = y & 1
@@ -912,20 +912,20 @@ def f(x: int, y: i64) -> bool:
 [out]
 def f(x, y):
     x :: int
-    y :: int64
+    y :: i64
     r0 :: native_int
     r1 :: bit
-    r2, r3, r4 :: int64
+    r2, r3, r4 :: i64
     r5 :: ptr
     r6 :: c_ptr
-    r7 :: int64
+    r7 :: i64
     r8 :: bit
 L0:
     r0 = x & 1
     r1 = r0 == 0
     if r1 goto L1 else goto L2 :: bool
 L1:
-    r2 = extend signed x: builtins.int to int64
+    r2 = extend signed x: builtins.int to i64
     r3 = r2 >> 1
     r4 = r3
     goto L3
@@ -949,7 +949,7 @@ def f(x: i64) -> i64:
     return 3
 [out]
 def f(x):
-    x :: int64
+    x :: i64
     r0, r1 :: bit
 L0:
     r0 = x != 0
@@ -975,14 +975,14 @@ def g(x: i64, y: int) -> int:
     return y
 [out]
 def f(x, y):
-    x :: int64
+    x :: i64
     y :: int
     r0 :: native_int
     r1 :: bit
-    r2, r3 :: int64
+    r2, r3 :: i64
     r4 :: ptr
     r5 :: c_ptr
-    r6 :: int64
+    r6 :: i64
 L0:
     r0 = y & 1
     r1 = r0 == 0
@@ -1001,7 +1001,7 @@ L3:
     x = r3
     return x
 def g(x, y):
-    x :: int64
+    x :: i64
     y :: int
     r0, r1 :: bit
     r2, r3, r4 :: int
@@ -1043,7 +1043,7 @@ class C:
 [out]
 def add_simple(c):
     c :: __main__.C
-    r0, r1, r2 :: int64
+    r0, r1, r2 :: i64
 L0:
     r0 = c.x
     r1 = c.y
@@ -1051,7 +1051,7 @@ L0:
     return r2
 def inplace_add_simple(c):
     c :: __main__.C
-    r0, r1, r2 :: int64
+    r0, r1, r2 :: i64
     r3 :: bool
 L0:
     r0 = c.x
@@ -1062,9 +1062,9 @@ L0:
 def add_borrow(d):
     d :: __main__.D
     r0 :: __main__.C
-    r1 :: int64
+    r1 :: i64
     r2 :: __main__.C
-    r3, r4 :: int64
+    r3, r4 :: i64
 L0:
     r0 = borrow d.c
     r1 = r0.x
@@ -1095,7 +1095,7 @@ class C:
 [out]
 def bitwise_simple(c):
     c :: __main__.C
-    r0, r1, r2 :: int64
+    r0, r1, r2 :: i64
 L0:
     r0 = c.x
     r1 = c.y
@@ -1103,7 +1103,7 @@ L0:
     return r2
 def inplace_bitwide_simple(c):
     c :: __main__.C
-    r0, r1, r2 :: int64
+    r0, r1, r2 :: i64
     r3 :: bool
 L0:
     r0 = c.x
@@ -1114,9 +1114,9 @@ L0:
 def bitwise_borrow(d):
     d :: __main__.D
     r0 :: __main__.C
-    r1 :: int64
+    r1 :: i64
     r2 :: __main__.C
-    r3, r4 :: int64
+    r3, r4 :: i64
 L0:
     r0 = borrow d.c
     r1 = r0.x
@@ -1137,7 +1137,7 @@ class C:
     s: str
 [out]
 def f(n):
-    n :: int64
+    n :: i64
     r0 :: __main__.C
     r1 :: list
     r2, r3 :: ptr
@@ -1170,13 +1170,13 @@ def f(a: List[i64], n: i64) -> bool:
 [out]
 def f(a, n):
     a :: list
-    n :: int64
+    n :: i64
     r0 :: object
-    r1 :: int64
+    r1 :: i64
     r2 :: bit
 L0:
     r0 = CPyList_GetItemInt64Borrow(a, n)
-    r1 = unbox(int64, r0)
+    r1 = unbox(i64, r0)
     r2 = r1 == 0
     keep_alive a, n
     if r2 goto L1 else goto L2 :: bool
@@ -1201,11 +1201,11 @@ def g(a: List[i64], y: i64) -> bool:
 [out]
 def f(a, y):
     a :: list
-    y :: int64
+    y :: i64
     r0 :: ptr
     r1 :: native_int
     r2 :: short_int
-    r3 :: int64
+    r3 :: i64
     r4 :: bit
 L0:
     r0 = get_element_ptr a ob_size :: PyVarObject
@@ -1221,11 +1221,11 @@ L2:
     return 0
 def g(a, y):
     a :: list
-    y :: int64
+    y :: i64
     r0 :: ptr
     r1 :: native_int
     r2 :: short_int
-    r3 :: int64
+    r3 :: i64
     r4 :: bit
 L0:
     r0 = get_element_ptr a ob_size :: PyVarObject
@@ -1248,7 +1248,7 @@ def f(n: i64) -> List[i64]:
     return [n] * n
 [out]
 def f(n):
-    n :: int64
+    n :: i64
     r0 :: list
     r1 :: object
     r2, r3 :: ptr
@@ -1257,7 +1257,7 @@ def f(n):
     r9 :: list
 L0:
     r0 = PyList_New(1)
-    r1 = box(int64, n)
+    r1 = box(i64, n)
     r2 = get_element_ptr r0 ob_item :: PyListObject
     r3 = load_mem r2 :: ptr*
     set_mem r3, r1 :: builtins.object*
@@ -1297,11 +1297,11 @@ def lt_i64(a: List[i64], n: i64) -> bool:
 [out]
 def add_i64(a, n):
     a :: list
-    n :: int64
+    n :: i64
     r0 :: ptr
     r1 :: native_int
     r2 :: short_int
-    r3, r4 :: int64
+    r3, r4 :: i64
 L0:
     r0 = get_element_ptr a ob_size :: PyVarObject
     r1 = load_mem r0 :: native_int*
@@ -1312,11 +1312,11 @@ L0:
     return r4
 def add_i64_2(a, n):
     a :: list
-    n :: int64
+    n :: i64
     r0 :: ptr
     r1 :: native_int
     r2 :: short_int
-    r3, r4 :: int64
+    r3, r4 :: i64
 L0:
     r0 = get_element_ptr a ob_size :: PyVarObject
     r1 = load_mem r0 :: native_int*
@@ -1327,11 +1327,11 @@ L0:
     return r4
 def eq_i64(a, n):
     a :: list
-    n :: int64
+    n :: i64
     r0 :: ptr
     r1 :: native_int
     r2 :: short_int
-    r3 :: int64
+    r3 :: i64
     r4 :: bit
 L0:
     r0 = get_element_ptr a ob_size :: PyVarObject
@@ -1347,11 +1347,11 @@ L2:
     return 0
 def lt_i64(a, n):
     a :: list
-    n :: int64
+    n :: i64
     r0 :: ptr
     r1 :: native_int
     r2 :: short_int
-    r3 :: int64
+    r3 :: i64
     r4 :: bit
 L0:
     r0 = get_element_ptr a ob_size :: PyVarObject
@@ -1376,10 +1376,10 @@ def f(x: Optional[i64]) -> i64:
     return x
 [out]
 def f(x):
-    x :: union[int64, None]
+    x :: union[i64, None]
     r0 :: object
     r1 :: bit
-    r2 :: int64
+    r2 :: i64
 L0:
     r0 = load_address _Py_NoneStruct
     r1 = x == r0
@@ -1387,7 +1387,7 @@ L0:
 L1:
     return 1
 L2:
-    r2 = unbox(int64, x)
+    r2 = unbox(i64, x)
     return r2
 
 [case testI64DefaultValueSingle]
@@ -1400,10 +1400,10 @@ def g() -> i64:
     return f(7) + f(8, 9)
 [out]
 def f(x, y, __bitmap):
-    x, y :: int64
-    __bitmap, r0 :: uint32
+    x, y :: i64
+    __bitmap, r0 :: u32
     r1 :: bit
-    r2 :: int64
+    r2 :: i64
 L0:
     r0 = __bitmap & 1
     r1 = r0 == 0
@@ -1414,7 +1414,7 @@ L2:
     r2 = x + y
     return r2
 def g():
-    r0, r1, r2 :: int64
+    r0, r1, r2 :: i64
 L0:
     r0 = f(7, 0, 0)
     r1 = f(8, 9, 1)
@@ -1431,12 +1431,12 @@ def g() -> i64:
     return f(7) + f(8, 9) + f(1, 2, 3) + f(4, 5, 6, 7)
 [out]
 def f(a, b, c, d, __bitmap):
-    a, b :: int64
+    a, b :: i64
     c :: int
-    d :: int64
-    __bitmap, r0 :: uint32
+    d :: i64
+    __bitmap, r0 :: u32
     r1 :: bit
-    r2 :: uint32
+    r2 :: u32
     r3 :: bit
 L0:
     r0 = __bitmap & 1
@@ -1458,9 +1458,9 @@ L6:
     return 0
 def g():
     r0 :: int
-    r1 :: int64
+    r1 :: i64
     r2 :: int
-    r3, r4, r5, r6, r7, r8 :: int64
+    r3, r4, r5, r6, r7, r8 :: i64
 L0:
     r0 = <error> :: int
     r1 = f(7, 0, r0, 0, 0)
@@ -1486,8 +1486,8 @@ def f(c: C) -> None:
 [out]
 def C.m(self, x, __bitmap):
     self :: __main__.C
-    x :: int64
-    __bitmap, r0 :: uint32
+    x :: i64
+    __bitmap, r0 :: u32
     r1 :: bit
 L0:
     r0 = __bitmap & 1
@@ -1518,19 +1518,19 @@ def from_i64(x: i64) -> i64:
     return i64(x)
 [out]
 def from_i16(x):
-    x :: int16
-    r0 :: int64
+    x :: i16
+    r0 :: i64
 L0:
-    r0 = extend signed x: int16 to int64
+    r0 = extend signed x: i16 to i64
     return r0
 def from_i32(x):
-    x :: int32
-    r0 :: int64
+    x :: i32
+    r0 :: i64
 L0:
-    r0 = extend signed x: int32 to int64
+    r0 = extend signed x: i32 to i64
     return r0
 def from_i64(x):
-    x :: int64
+    x :: i64
 L0:
     return x
 
@@ -1544,10 +1544,10 @@ def f(x):
     x :: int
     r0 :: native_int
     r1 :: bit
-    r2, r3 :: int64
+    r2, r3 :: i64
     r4 :: ptr
     r5 :: c_ptr
-    r6 :: int64
+    r6 :: i64
 L0:
     r0 = x & 1
     r1 = r0 == 0
@@ -1572,7 +1572,7 @@ def f(x: i64) -> int:
     return int(x)
 [out]
 def f(x):
-    x :: int64
+    x :: i64
     r0, r1 :: bit
     r2, r3, r4 :: int
 L0:
@@ -1600,7 +1600,7 @@ def f() -> None:
     z = i64(-3)
 [out]
 def f():
-    x, y, z :: int64
+    x, y, z :: i64
 L0:
     x = 0
     y = 11
@@ -1615,9 +1615,9 @@ def f() -> None:
         y = x
 [out]
 def f():
-    r0, x :: int64
+    r0, x :: i64
     r1 :: bit
-    y, r2 :: int64
+    y, r2 :: i64
 L0:
     r0 = 0
     x = r0
@@ -1642,9 +1642,9 @@ def f() -> None:
         y = x
 [out]
 def f():
-    r0, x :: int64
+    r0, x :: i64
     r1 :: bit
-    y, r2 :: int64
+    y, r2 :: i64
 L0:
     r0 = 0
     x = r0
@@ -1671,8 +1671,8 @@ class D(C):
 [out]
 def C.f(self, x, __bitmap):
     self :: __main__.C
-    x :: int64
-    __bitmap, r0 :: uint32
+    x :: i64
+    __bitmap, r0 :: u32
     r1 :: bit
 L0:
     r0 = __bitmap & 1
@@ -1684,8 +1684,8 @@ L2:
     return 1
 def D.f(self, x, __bitmap):
     self :: __main__.D
-    x :: int64
-    __bitmap, r0 :: uint32
+    x :: i64
+    __bitmap, r0 :: u32
     r1 :: bit
 L0:
     r0 = __bitmap & 1
@@ -1751,26 +1751,26 @@ def compare_bool_to_i64(n: i64, b: bool) -> bool:
     return True
 [out]
 def add_bool_to_int(n, b):
-    n :: int64
+    n :: i64
     b :: bool
-    r0, r1 :: int64
+    r0, r1 :: i64
 L0:
-    r0 = extend b: builtins.bool to int64
+    r0 = extend b: builtins.bool to i64
     r1 = n + r0
     return r1
 def compare_bool_to_i64(n, b):
-    n :: int64
+    n :: i64
     b :: bool
-    r0 :: int64
+    r0 :: i64
     r1 :: bit
-    r2 :: int64
+    r2 :: i64
     r3 :: bit
 L0:
-    r0 = extend b: builtins.bool to int64
+    r0 = extend b: builtins.bool to i64
     r1 = n == r0
     if r1 goto L1 else goto L2 :: bool
 L1:
-    r2 = extend b: builtins.bool to int64
+    r2 = extend b: builtins.bool to i64
     r3 = r2 != n
     return r3
 L2:
@@ -1788,18 +1788,18 @@ def cast_int(x: int) -> i64:
 [out]
 def cast_object(o):
     o :: object
-    r0 :: int64
+    r0 :: i64
 L0:
-    r0 = unbox(int64, o)
+    r0 = unbox(i64, o)
     return r0
 def cast_int(x):
     x :: int
     r0 :: native_int
     r1 :: bit
-    r2, r3 :: int64
+    r2, r3 :: i64
     r4 :: ptr
     r5 :: c_ptr
-    r6 :: int64
+    r6 :: i64
 L0:
     r0 = x & 1
     r1 = r0 == 0
@@ -1828,16 +1828,16 @@ def cast_int(x):
     x :: int
     r0 :: native_int
     r1 :: bit
-    r2, r3, r4 :: int64
+    r2, r3, r4 :: i64
     r5 :: ptr
     r6 :: c_ptr
-    r7 :: int64
+    r7 :: i64
 L0:
     r0 = x & 1
     r1 = r0 == 0
     if r1 goto L1 else goto L2 :: bool
 L1:
-    r2 = extend signed x: builtins.int to int64
+    r2 = extend signed x: builtins.int to i64
     r3 = r2 >> 1
     r4 = r3
     goto L3
@@ -1874,25 +1874,25 @@ def float_to_i64(x: float) -> i64:
 [out]
 def bool_to_i64(b):
     b :: bool
-    r0 :: int64
+    r0 :: i64
 L0:
-    r0 = extend b: builtins.bool to int64
+    r0 = extend b: builtins.bool to i64
     return r0
 def str_to_i64(s):
     s :: str
     r0 :: object
-    r1 :: int64
+    r1 :: i64
 L0:
     r0 = CPyLong_FromStr(s)
-    r1 = unbox(int64, r0)
+    r1 = unbox(i64, r0)
     return r1
 def str_to_i64_with_base(s):
     s :: str
     r0 :: object
-    r1 :: int64
+    r1 :: i64
 L0:
     r0 = CPyLong_FromStrWithBase(s, 4)
-    r1 = unbox(int64, r0)
+    r1 = unbox(i64, r0)
     return r1
 def C.__int__(self):
     self :: __main__.C
@@ -1900,7 +1900,7 @@ L0:
     return 5
 def instance_to_i64(c):
     c :: __main__.C
-    r0 :: int64
+    r0 :: i64
 L0:
     r0 = c.__int__()
     return r0
@@ -1909,10 +1909,10 @@ def float_to_i64(x):
     r0 :: int
     r1 :: native_int
     r2 :: bit
-    r3, r4 :: int64
+    r3, r4 :: i64
     r5 :: ptr
     r6 :: c_ptr
-    r7 :: int64
+    r7 :: i64
 L0:
     r0 = CPyTagged_FromFloat(x)
     r1 = r0 & 1
@@ -1942,17 +1942,17 @@ def float_to_i64(x):
     r0 :: int
     r1 :: native_int
     r2 :: bit
-    r3, r4, r5 :: int64
+    r3, r4, r5 :: i64
     r6 :: ptr
     r7 :: c_ptr
-    r8 :: int64
+    r8 :: i64
 L0:
     r0 = CPyTagged_FromFloat(x)
     r1 = r0 & 1
     r2 = r1 == 0
     if r2 goto L1 else goto L2 :: bool
 L1:
-    r3 = extend signed r0: builtins.int to int64
+    r3 = extend signed r0: builtins.int to i64
     r4 = r3 >> 1
     r5 = r4
     goto L3
@@ -1972,7 +1972,7 @@ def i64_to_float(x: i64) -> float:
     return float(x)
 [out]
 def i64_to_float(x):
-    x :: int64
+    x :: i64
     r0, r1 :: bit
     r2, r3, r4 :: int
     r5 :: float
@@ -2000,7 +2000,7 @@ def i64_to_float(x: i64) -> float:
     return float(x)
 [out]
 def i64_to_float(x):
-    x :: int64
+    x :: i64
     r0, r1 :: bit
     r2, r3 :: int
     r4 :: native_int
@@ -2017,7 +2017,7 @@ L2:
     r3 = r2
     goto L4
 L3:
-    r4 = truncate x: int64 to native_int
+    r4 = truncate x: i64 to native_int
     r5 = r4 << 1
     r3 = r5
 L4:
@@ -2042,22 +2042,22 @@ def narrow2(x: Union[C, i64]) -> i64:
     return x.a
 [out]
 def narrow1(x):
-    x :: union[__main__.C, int64]
+    x :: union[__main__.C, i64]
     r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3 :: bool
-    r4 :: int64
+    r4 :: i64
     r5 :: __main__.C
-    r6 :: int64
+    r6 :: i64
 L0:
     r0 = load_address PyLong_Type
     r1 = PyObject_IsInstance(x, r0)
     r2 = r1 >= 0 :: signed
-    r3 = truncate r1: int32 to builtins.bool
+    r3 = truncate r1: i32 to builtins.bool
     if r3 goto L1 else goto L2 :: bool
 L1:
-    r4 = unbox(int64, x)
+    r4 = unbox(i64, x)
     return r4
 L2:
     r5 = borrow cast(__main__.C, x)
@@ -2065,22 +2065,22 @@ L2:
     keep_alive x
     return r6
 def narrow2(x):
-    x :: union[__main__.C, int64]
+    x :: union[__main__.C, i64]
     r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3 :: bool
-    r4 :: int64
+    r4 :: i64
     r5 :: __main__.C
-    r6 :: int64
+    r6 :: i64
 L0:
     r0 = load_address PyLong_Type
     r1 = PyObject_IsInstance(x, r0)
     r2 = r1 >= 0 :: signed
-    r3 = truncate r1: int32 to builtins.bool
+    r3 = truncate r1: i32 to builtins.bool
     if r3 goto L1 else goto L2 :: bool
 L1:
-    r4 = unbox(int64, x)
+    r4 = unbox(i64, x)
     return r4
 L2:
     r5 = borrow cast(__main__.C, x)
@@ -2099,17 +2099,17 @@ def g(n: int) -> None:
     t: tuple[i64, i64] = (1, n)
 [out]
 def f(t):
-    t :: tuple[int, int64, int]
+    t :: tuple[int, i64, int]
     r0 :: int
-    r1 :: int64
+    r1 :: i64
     r2 :: int
     r3 :: native_int
     r4 :: bit
-    r5, r6 :: int64
+    r5, r6 :: i64
     r7 :: ptr
     r8 :: c_ptr
-    r9 :: int64
-    r10, tt :: tuple[int, int64, int64]
+    r9 :: i64
+    r10, tt :: tuple[int, i64, i64]
 L0:
     r0 = t[0]
     r1 = t[1]
@@ -2137,11 +2137,11 @@ def g(n):
     r1 :: int
     r2 :: native_int
     r3 :: bit
-    r4, r5 :: int64
+    r4, r5 :: i64
     r6 :: ptr
     r7 :: c_ptr
-    r8 :: int64
-    r9, t :: tuple[int64, int64]
+    r8 :: i64
+    r9, t :: tuple[i64, i64]
 L0:
     r0 = (2, n)
     r1 = r0[1]
diff --git a/mypyc/test-data/irbuild-isinstance.test b/mypyc/test-data/irbuild-isinstance.test
index 6bb92d0a947e8..78da2e9c1e196 100644
--- a/mypyc/test-data/irbuild-isinstance.test
+++ b/mypyc/test-data/irbuild-isinstance.test
@@ -5,14 +5,14 @@ def is_int(value: object) -> bool:
 [out]
 def is_int(value):
     value, r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3 :: bool
 L0:
     r0 = load_address PyLong_Type
     r1 = PyObject_IsInstance(value, r0)
     r2 = r1 >= 0 :: signed
-    r3 = truncate r1: int32 to builtins.bool
+    r3 = truncate r1: i32 to builtins.bool
     return r3
 
 [case testIsinstanceNotBool1]
@@ -22,14 +22,14 @@ def is_not_bool(value: object) -> bool:
 [out]
 def is_not_bool(value):
     value, r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3, r4 :: bool
 L0:
     r0 = load_address PyBool_Type
     r1 = PyObject_IsInstance(value, r0)
     r2 = r1 >= 0 :: signed
-    r3 = truncate r1: int32 to builtins.bool
+    r3 = truncate r1: i32 to builtins.bool
     r4 = r3 ^ 1
     return r4
 
@@ -42,18 +42,18 @@ def is_not_bool_and_is_int(value: object) -> bool:
 [out]
 def is_not_bool_and_is_int(value):
     value, r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3, r4 :: bool
     r5 :: object
-    r6 :: int32
+    r6 :: i32
     r7 :: bit
     r8, r9 :: bool
 L0:
     r0 = load_address PyLong_Type
     r1 = PyObject_IsInstance(value, r0)
     r2 = r1 >= 0 :: signed
-    r3 = truncate r1: int32 to builtins.bool
+    r3 = truncate r1: i32 to builtins.bool
     if r3 goto L2 else goto L1 :: bool
 L1:
     r4 = r3
@@ -62,7 +62,7 @@ L2:
     r5 = load_address PyBool_Type
     r6 = PyObject_IsInstance(value, r5)
     r7 = r6 >= 0 :: signed
-    r8 = truncate r6: int32 to builtins.bool
+    r8 = truncate r6: i32 to builtins.bool
     r9 = r8 ^ 1
     r4 = r9
 L3:
diff --git a/mypyc/test-data/irbuild-lists.test b/mypyc/test-data/irbuild-lists.test
index eaeff9432446e..80c4fe5fcd5e0 100644
--- a/mypyc/test-data/irbuild-lists.test
+++ b/mypyc/test-data/irbuild-lists.test
@@ -197,7 +197,7 @@ def f(a, x):
     a :: list
     x :: int
     r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
 L0:
     r0 = box(int, x)
@@ -255,7 +255,7 @@ def f(x, y):
     r1, r2 :: object
     r3, r4, r5 :: ptr
     r6, r7, r8 :: object
-    r9 :: int32
+    r9 :: i32
     r10 :: bit
 L0:
     r0 = PyList_New(2)
@@ -283,14 +283,14 @@ def f(x, y):
     x :: list
     y :: int
     r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3 :: bool
 L0:
     r0 = box(int, y)
     r1 = PySequence_Contains(x, r0)
     r2 = r1 >= 0 :: signed
-    r3 = truncate r1: int32 to builtins.bool
+    r3 = truncate r1: i32 to builtins.bool
     return r3
 
 [case testListInsert]
@@ -302,7 +302,7 @@ def f(x, y):
     x :: list
     y :: int
     r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
 L0:
     r0 = box(int, y)
@@ -462,7 +462,7 @@ def nested_union(a: Union[List[str], List[Optional[str]]]) -> None:
 def narrow(a):
     a :: union[list, int]
     r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3 :: bool
     r4 :: list
@@ -474,7 +474,7 @@ L0:
     r0 = load_address PyList_Type
     r1 = PyObject_IsInstance(a, r0)
     r2 = r1 >= 0 :: signed
-    r3 = truncate r1: int32 to builtins.bool
+    r3 = truncate r1: i32 to builtins.bool
     if r3 goto L1 else goto L2 :: bool
 L1:
     r4 = borrow cast(list, a)
diff --git a/mypyc/test-data/irbuild-match.test b/mypyc/test-data/irbuild-match.test
index 2afe3d862f517..a078ae0defdbf 100644
--- a/mypyc/test-data/irbuild-match.test
+++ b/mypyc/test-data/irbuild-match.test
@@ -608,22 +608,22 @@ L0:
     return 1
 def f(x):
     x, r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3 :: bool
     r4 :: str
     r5, r6, r7 :: object
-    r8 :: int32
+    r8 :: i32
     r9 :: bit
     r10 :: bool
     r11 :: str
     r12, r13, r14 :: object
-    r15 :: int32
+    r15 :: i32
     r16 :: bit
     r17 :: bool
     r18 :: str
     r19, r20, r21 :: object
-    r22 :: int32
+    r22 :: i32
     r23 :: bit
     r24 :: bool
     r25 :: str
@@ -637,7 +637,7 @@ L0:
     r0 = __main__.Position :: type
     r1 = PyObject_IsInstance(x, r0)
     r2 = r1 >= 0 :: signed
-    r3 = truncate r1: int32 to builtins.bool
+    r3 = truncate r1: i32 to builtins.bool
     if r3 goto L1 else goto L5 :: bool
 L1:
     r4 = 'x'
@@ -646,7 +646,7 @@ L1:
     r7 = PyObject_RichCompare(r5, r6, 2)
     r8 = PyObject_IsTrue(r7)
     r9 = r8 >= 0 :: signed
-    r10 = truncate r8: int32 to builtins.bool
+    r10 = truncate r8: i32 to builtins.bool
     if r10 goto L2 else goto L5 :: bool
 L2:
     r11 = 'y'
@@ -655,7 +655,7 @@ L2:
     r14 = PyObject_RichCompare(r12, r13, 2)
     r15 = PyObject_IsTrue(r14)
     r16 = r15 >= 0 :: signed
-    r17 = truncate r15: int32 to builtins.bool
+    r17 = truncate r15: i32 to builtins.bool
     if r17 goto L3 else goto L5 :: bool
 L3:
     r18 = 'z'
@@ -664,7 +664,7 @@ L3:
     r21 = PyObject_RichCompare(r19, r20, 2)
     r22 = PyObject_IsTrue(r21)
     r23 = r22 >= 0 :: signed
-    r24 = truncate r22: int32 to builtins.bool
+    r24 = truncate r22: i32 to builtins.bool
     if r24 goto L4 else goto L5 :: bool
 L4:
     r25 = 'matched'
@@ -693,22 +693,22 @@ def f(x):
 [out]
 def f(x):
     x, r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3 :: bool
     r4 :: str
     r5, r6, r7 :: object
-    r8 :: int32
+    r8 :: i32
     r9 :: bit
     r10 :: bool
     r11 :: str
     r12, r13, r14 :: object
-    r15 :: int32
+    r15 :: i32
     r16 :: bit
     r17 :: bool
     r18 :: str
     r19, r20, r21 :: object
-    r22 :: int32
+    r22 :: i32
     r23 :: bit
     r24 :: bool
     r25 :: str
@@ -722,7 +722,7 @@ L0:
     r0 = __main__.Position :: type
     r1 = PyObject_IsInstance(x, r0)
     r2 = r1 >= 0 :: signed
-    r3 = truncate r1: int32 to builtins.bool
+    r3 = truncate r1: i32 to builtins.bool
     if r3 goto L1 else goto L5 :: bool
 L1:
     r4 = 'z'
@@ -731,7 +731,7 @@ L1:
     r7 = PyObject_RichCompare(r5, r6, 2)
     r8 = PyObject_IsTrue(r7)
     r9 = r8 >= 0 :: signed
-    r10 = truncate r8: int32 to builtins.bool
+    r10 = truncate r8: i32 to builtins.bool
     if r10 goto L2 else goto L5 :: bool
 L2:
     r11 = 'y'
@@ -740,7 +740,7 @@ L2:
     r14 = PyObject_RichCompare(r12, r13, 2)
     r15 = PyObject_IsTrue(r14)
     r16 = r15 >= 0 :: signed
-    r17 = truncate r15: int32 to builtins.bool
+    r17 = truncate r15: i32 to builtins.bool
     if r17 goto L3 else goto L5 :: bool
 L3:
     r18 = 'x'
@@ -749,7 +749,7 @@ L3:
     r21 = PyObject_RichCompare(r19, r20, 2)
     r22 = PyObject_IsTrue(r21)
     r23 = r22 >= 0 :: signed
-    r24 = truncate r22: int32 to builtins.bool
+    r24 = truncate r22: i32 to builtins.bool
     if r24 goto L4 else goto L5 :: bool
 L4:
     r25 = 'matched'
@@ -776,16 +776,16 @@ def f(x):
 [out]
 def f(x):
     x, r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3 :: bool
     r4 :: str
     r5, r6, r7 :: object
-    r8 :: int32
+    r8 :: i32
     r9 :: bit
     r10 :: bool
     r11, r12 :: object
-    r13 :: int32
+    r13 :: i32
     r14 :: bit
     r15 :: bool
     r16 :: str
@@ -799,7 +799,7 @@ L0:
     r0 = __main__.C :: type
     r1 = PyObject_IsInstance(x, r0)
     r2 = r1 >= 0 :: signed
-    r3 = truncate r1: int32 to builtins.bool
+    r3 = truncate r1: i32 to builtins.bool
     if r3 goto L1 else goto L5 :: bool
 L1:
     r4 = 'num'
@@ -808,14 +808,14 @@ L1:
     r7 = PyObject_RichCompare(r5, r6, 2)
     r8 = PyObject_IsTrue(r7)
     r9 = r8 >= 0 :: signed
-    r10 = truncate r8: int32 to builtins.bool
+    r10 = truncate r8: i32 to builtins.bool
     if r10 goto L4 else goto L2 :: bool
 L2:
     r11 = object 2
     r12 = PyObject_RichCompare(r5, r11, 2)
     r13 = PyObject_IsTrue(r12)
     r14 = r13 >= 0 :: signed
-    r15 = truncate r13: int32 to builtins.bool
+    r15 = truncate r13: i32 to builtins.bool
     if r15 goto L4 else goto L3 :: bool
 L3:
     goto L5
@@ -856,18 +856,18 @@ L0:
     return 1
 def f(x):
     x, r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3 :: bool
     r4, y :: __main__.C
     r5 :: str
     r6, r7, r8 :: object
-    r9 :: int32
+    r9 :: i32
     r10 :: bit
     r11 :: bool
     r12 :: str
     r13, r14, r15 :: object
-    r16 :: int32
+    r16 :: i32
     r17 :: bit
     r18 :: bool
     r19 :: str
@@ -881,7 +881,7 @@ L0:
     r0 = __main__.C :: type
     r1 = PyObject_IsInstance(x, r0)
     r2 = r1 >= 0 :: signed
-    r3 = truncate r1: int32 to builtins.bool
+    r3 = truncate r1: i32 to builtins.bool
     if r3 goto L1 else goto L5 :: bool
 L1:
     r4 = cast(__main__.C, x)
@@ -893,7 +893,7 @@ L2:
     r8 = PyObject_RichCompare(r6, r7, 2)
     r9 = PyObject_IsTrue(r8)
     r10 = r9 >= 0 :: signed
-    r11 = truncate r9: int32 to builtins.bool
+    r11 = truncate r9: i32 to builtins.bool
     if r11 goto L3 else goto L5 :: bool
 L3:
     r12 = 'b'
@@ -902,7 +902,7 @@ L3:
     r15 = PyObject_RichCompare(r13, r14, 2)
     r16 = PyObject_IsTrue(r15)
     r17 = r16 >= 0 :: signed
-    r18 = truncate r16: int32 to builtins.bool
+    r18 = truncate r16: i32 to builtins.bool
     if r18 goto L4 else goto L5 :: bool
 L4:
     r19 = 'matched'
@@ -940,7 +940,7 @@ L0:
     return 1
 def f(x):
     x, r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3 :: bool
     r4 :: str
@@ -957,7 +957,7 @@ L0:
     r0 = __main__.C :: type
     r1 = PyObject_IsInstance(x, r0)
     r2 = r1 >= 0 :: signed
-    r3 = truncate r1: int32 to builtins.bool
+    r3 = truncate r1: i32 to builtins.bool
     if r3 goto L1 else goto L3 :: bool
 L1:
     r4 = 'x'
@@ -986,7 +986,7 @@ def f(x):
 [out]
 def f(x):
     x :: object
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
     r2 :: str
     r3 :: object
@@ -1021,15 +1021,15 @@ def f(x):
 [out]
 def f(x):
     x :: object
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
     r2 :: str
-    r3 :: int32
+    r3 :: i32
     r4 :: bit
     r5 :: object
     r6 :: str
     r7 :: object
-    r8 :: int32
+    r8 :: i32
     r9 :: bit
     r10 :: bool
     r11 :: str
@@ -1054,7 +1054,7 @@ L2:
     r7 = PyObject_RichCompare(r5, r6, 2)
     r8 = PyObject_IsTrue(r7)
     r9 = r8 >= 0 :: signed
-    r10 = truncate r8: int32 to builtins.bool
+    r10 = truncate r8: i32 to builtins.bool
     if r10 goto L3 else goto L4 :: bool
 L3:
     r11 = 'matched'
@@ -1078,7 +1078,7 @@ def f(x):
 [out]
 def f(x):
     x :: object
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
     r2, rest :: dict
     r3 :: str
@@ -1117,19 +1117,19 @@ def f(x):
 [out]
 def f(x):
     x :: object
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
     r2 :: str
-    r3 :: int32
+    r3 :: i32
     r4 :: bit
     r5 :: object
     r6 :: str
     r7 :: object
-    r8 :: int32
+    r8 :: i32
     r9 :: bit
     r10 :: bool
     r11, rest :: dict
-    r12 :: int32
+    r12 :: i32
     r13 :: bit
     r14 :: str
     r15 :: object
@@ -1153,7 +1153,7 @@ L2:
     r7 = PyObject_RichCompare(r5, r6, 2)
     r8 = PyObject_IsTrue(r7)
     r9 = r8 >= 0 :: signed
-    r10 = truncate r8: int32 to builtins.bool
+    r10 = truncate r8: i32 to builtins.bool
     if r10 goto L3 else goto L5 :: bool
 L3:
     r11 = CPyDict_FromAny(x)
@@ -1182,7 +1182,7 @@ def f(x):
 [out]
 def f(x):
     x :: object
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
     r2 :: native_int
     r3, r4 :: bit
@@ -1224,16 +1224,16 @@ def f(x):
 [out]
 def f(x):
     x :: object
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
     r2 :: native_int
     r3, r4 :: bit
     r5, r6, r7 :: object
-    r8 :: int32
+    r8 :: i32
     r9 :: bit
     r10 :: bool
     r11, r12, r13 :: object
-    r14 :: int32
+    r14 :: i32
     r15 :: bit
     r16 :: bool
     r17 :: str
@@ -1258,7 +1258,7 @@ L2:
     r7 = PyObject_RichCompare(r5, r6, 2)
     r8 = PyObject_IsTrue(r7)
     r9 = r8 >= 0 :: signed
-    r10 = truncate r8: int32 to builtins.bool
+    r10 = truncate r8: i32 to builtins.bool
     if r10 goto L3 else goto L5 :: bool
 L3:
     r11 = PySequence_GetItem(x, 1)
@@ -1266,7 +1266,7 @@ L3:
     r13 = PyObject_RichCompare(r11, r12, 2)
     r14 = PyObject_IsTrue(r13)
     r15 = r14 >= 0 :: signed
-    r16 = truncate r14: int32 to builtins.bool
+    r16 = truncate r14: i32 to builtins.bool
     if r16 goto L4 else goto L5 :: bool
 L4:
     r17 = 'matched'
@@ -1290,16 +1290,16 @@ def f(x):
 [out]
 def f(x):
     x :: object
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
     r2 :: native_int
     r3, r4 :: bit
     r5, r6, r7 :: object
-    r8 :: int32
+    r8 :: i32
     r9 :: bit
     r10 :: bool
     r11, r12, r13 :: object
-    r14 :: int32
+    r14 :: i32
     r15 :: bit
     r16 :: bool
     r17 :: str
@@ -1324,7 +1324,7 @@ L2:
     r7 = PyObject_RichCompare(r5, r6, 2)
     r8 = PyObject_IsTrue(r7)
     r9 = r8 >= 0 :: signed
-    r10 = truncate r8: int32 to builtins.bool
+    r10 = truncate r8: i32 to builtins.bool
     if r10 goto L3 else goto L5 :: bool
 L3:
     r11 = PySequence_GetItem(x, 1)
@@ -1332,7 +1332,7 @@ L3:
     r13 = PyObject_RichCompare(r11, r12, 2)
     r14 = PyObject_IsTrue(r13)
     r15 = r14 >= 0 :: signed
-    r16 = truncate r14: int32 to builtins.bool
+    r16 = truncate r14: i32 to builtins.bool
     if r16 goto L4 else goto L5 :: bool
 L4:
     r17 = 'matched'
@@ -1356,16 +1356,16 @@ def f(x):
 [out]
 def f(x):
     x :: object
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
     r2 :: native_int
     r3, r4 :: bit
     r5, r6, r7 :: object
-    r8 :: int32
+    r8 :: i32
     r9 :: bit
     r10 :: bool
     r11, r12, r13 :: object
-    r14 :: int32
+    r14 :: i32
     r15 :: bit
     r16 :: bool
     r17 :: native_int
@@ -1392,7 +1392,7 @@ L2:
     r7 = PyObject_RichCompare(r5, r6, 2)
     r8 = PyObject_IsTrue(r7)
     r9 = r8 >= 0 :: signed
-    r10 = truncate r8: int32 to builtins.bool
+    r10 = truncate r8: i32 to builtins.bool
     if r10 goto L3 else goto L6 :: bool
 L3:
     r11 = PySequence_GetItem(x, 1)
@@ -1400,7 +1400,7 @@ L3:
     r13 = PyObject_RichCompare(r11, r12, 2)
     r14 = PyObject_IsTrue(r13)
     r15 = r14 >= 0 :: signed
-    r16 = truncate r14: int32 to builtins.bool
+    r16 = truncate r14: i32 to builtins.bool
     if r16 goto L4 else goto L6 :: bool
 L4:
     r17 = r2 - 0
@@ -1428,21 +1428,21 @@ def f(x):
 [out]
 def f(x):
     x :: object
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
     r2 :: native_int
     r3, r4 :: bit
     r5 :: object
     r6 :: str
     r7 :: object
-    r8 :: int32
+    r8 :: i32
     r9 :: bit
     r10 :: bool
     r11 :: native_int
     r12 :: object
     r13 :: str
     r14 :: object
-    r15 :: int32
+    r15 :: i32
     r16 :: bit
     r17 :: bool
     r18 :: native_int
@@ -1469,7 +1469,7 @@ L2:
     r7 = PyObject_RichCompare(r5, r6, 2)
     r8 = PyObject_IsTrue(r7)
     r9 = r8 >= 0 :: signed
-    r10 = truncate r8: int32 to builtins.bool
+    r10 = truncate r8: i32 to builtins.bool
     if r10 goto L3 else goto L6 :: bool
 L3:
     r11 = r2 - 1
@@ -1478,7 +1478,7 @@ L3:
     r14 = PyObject_RichCompare(r12, r13, 2)
     r15 = PyObject_IsTrue(r14)
     r16 = r15 >= 0 :: signed
-    r17 = truncate r15: int32 to builtins.bool
+    r17 = truncate r15: i32 to builtins.bool
     if r17 goto L4 else goto L6 :: bool
 L4:
     r18 = r2 - 1
@@ -1506,18 +1506,18 @@ def f(x):
 [out]
 def f(x):
     x :: object
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
     r2 :: native_int
     r3, r4 :: bit
     r5 :: native_int
     r6, r7, r8 :: object
-    r9 :: int32
+    r9 :: i32
     r10 :: bit
     r11 :: bool
     r12 :: native_int
     r13, r14, r15 :: object
-    r16 :: int32
+    r16 :: i32
     r17 :: bit
     r18 :: bool
     r19 :: native_int
@@ -1545,7 +1545,7 @@ L2:
     r8 = PyObject_RichCompare(r6, r7, 2)
     r9 = PyObject_IsTrue(r8)
     r10 = r9 >= 0 :: signed
-    r11 = truncate r9: int32 to builtins.bool
+    r11 = truncate r9: i32 to builtins.bool
     if r11 goto L3 else goto L6 :: bool
 L3:
     r12 = r2 - 1
@@ -1554,7 +1554,7 @@ L3:
     r15 = PyObject_RichCompare(r13, r14, 2)
     r16 = PyObject_IsTrue(r15)
     r17 = r16 >= 0 :: signed
-    r18 = truncate r16: int32 to builtins.bool
+    r18 = truncate r16: i32 to builtins.bool
     if r18 goto L4 else goto L6 :: bool
 L4:
     r19 = r2 - 2
@@ -1620,7 +1620,7 @@ def f(x):
 [out]
 def f(x):
     x :: object
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
     r2 :: native_int
     r3, r4 :: bit
@@ -1674,7 +1674,7 @@ def f(x: A | int) -> int:
 def f(x):
     x :: union[__main__.A, int]
     r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3 :: bool
     r4 :: str
@@ -1687,7 +1687,7 @@ L0:
     r0 = __main__.A :: type
     r1 = PyObject_IsInstance(x, r0)
     r2 = r1 >= 0 :: signed
-    r3 = truncate r1: int32 to builtins.bool
+    r3 = truncate r1: i32 to builtins.bool
     if r3 goto L1 else goto L3 :: bool
 L1:
     r4 = 'a'
diff --git a/mypyc/test-data/irbuild-optional.test b/mypyc/test-data/irbuild-optional.test
index e98cf1b19e2e9..e89018a727dab 100644
--- a/mypyc/test-data/irbuild-optional.test
+++ b/mypyc/test-data/irbuild-optional.test
@@ -91,7 +91,7 @@ def f(x):
     r0 :: object
     r1 :: bit
     r2 :: __main__.A
-    r3 :: int32
+    r3 :: i32
     r4 :: bit
     r5 :: bool
 L0:
@@ -102,7 +102,7 @@ L1:
     r2 = cast(__main__.A, x)
     r3 = PyObject_IsTrue(r2)
     r4 = r3 >= 0 :: signed
-    r5 = truncate r3: int32 to builtins.bool
+    r5 = truncate r3: i32 to builtins.bool
     if r5 goto L2 else goto L3 :: bool
 L2:
     return 2
@@ -252,7 +252,7 @@ def f(x: Union[int, A]) -> int:
 def f(x):
     x :: union[int, __main__.A]
     r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3 :: bool
     r4, r5 :: int
@@ -262,7 +262,7 @@ L0:
     r0 = load_address PyLong_Type
     r1 = PyObject_IsInstance(x, r0)
     r2 = r1 >= 0 :: signed
-    r3 = truncate r1: int32 to builtins.bool
+    r3 = truncate r1: i32 to builtins.bool
     if r3 goto L1 else goto L2 :: bool
 L1:
     r4 = unbox(int, x)
@@ -337,7 +337,7 @@ L3:
 def set(o, s):
     o :: union[__main__.A, __main__.B]
     s, r0 :: str
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
 L0:
     r0 = 'a'
diff --git a/mypyc/test-data/irbuild-set.test b/mypyc/test-data/irbuild-set.test
index b6c551124769a..a56ebe3438fa0 100644
--- a/mypyc/test-data/irbuild-set.test
+++ b/mypyc/test-data/irbuild-set.test
@@ -6,13 +6,13 @@ def f() -> Set[int]:
 def f():
     r0 :: set
     r1 :: object
-    r2 :: int32
+    r2 :: i32
     r3 :: bit
     r4 :: object
-    r5 :: int32
+    r5 :: i32
     r6 :: bit
     r7 :: object
-    r8 :: int32
+    r8 :: i32
     r9 :: bit
 L0:
     r0 = PySet_New(0)
@@ -90,7 +90,7 @@ def test1():
     r14 :: object
     r15, x, r16 :: int
     r17 :: object
-    r18 :: int32
+    r18 :: i32
     r19 :: bit
     r20 :: short_int
     a :: set
@@ -138,7 +138,7 @@ def test2():
     r2, r3, r4 :: object
     r5, x, r6 :: int
     r7 :: object
-    r8 :: int32
+    r8 :: i32
     r9, r10 :: bit
     b :: set
 L0:
@@ -179,7 +179,7 @@ def test3():
     r15 :: object
     r16, x, r17 :: int
     r18 :: object
-    r19 :: int32
+    r19 :: i32
     r20, r21, r22 :: bit
     c :: set
 L0:
@@ -225,7 +225,7 @@ def test4():
     r2 :: bit
     r3 :: int
     r4 :: object
-    r5 :: int32
+    r5 :: i32
     r6 :: bit
     r7 :: short_int
     d :: set
@@ -256,7 +256,7 @@ def test5():
     r2 :: bit
     r3 :: int
     r4 :: object
-    r5 :: int32
+    r5 :: i32
     r6 :: bit
     r7 :: short_int
     e :: set
@@ -331,18 +331,18 @@ def test():
     r29 :: bit
     r30 :: int
     r31 :: object
-    r32 :: int32
+    r32 :: i32
     r33 :: bit
     r34 :: short_int
     r35, r36, r37 :: object
     r38, y, r39 :: int
     r40 :: object
-    r41 :: int32
+    r41 :: i32
     r42, r43 :: bit
     r44, r45, r46 :: object
     r47, x, r48 :: int
     r49 :: object
-    r50 :: int32
+    r50 :: i32
     r51, r52 :: bit
     a :: set
 L0:
@@ -452,13 +452,13 @@ def f() -> int:
 def f():
     r0 :: set
     r1 :: object
-    r2 :: int32
+    r2 :: i32
     r3 :: bit
     r4 :: object
-    r5 :: int32
+    r5 :: i32
     r6 :: bit
     r7 :: object
-    r8 :: int32
+    r8 :: i32
     r9 :: bit
     r10 :: ptr
     r11 :: native_int
@@ -489,14 +489,14 @@ def f() -> bool:
 def f():
     r0 :: set
     r1 :: object
-    r2 :: int32
+    r2 :: i32
     r3 :: bit
     r4 :: object
-    r5 :: int32
+    r5 :: i32
     r6 :: bit
     x :: set
     r7 :: object
-    r8 :: int32
+    r8 :: i32
     r9 :: bit
     r10 :: bool
 L0:
@@ -511,7 +511,7 @@ L0:
     r7 = object 5
     r8 = PySet_Contains(x, r7)
     r9 = r8 >= 0 :: signed
-    r10 = truncate r8: int32 to builtins.bool
+    r10 = truncate r8: i32 to builtins.bool
     return r10
 
 [case testSetRemove]
@@ -542,7 +542,7 @@ def f() -> Set[int]:
 def f():
     r0, x :: set
     r1 :: object
-    r2 :: int32
+    r2 :: i32
     r3 :: bit
 L0:
     r0 = PySet_New(0)
@@ -562,7 +562,7 @@ def f() -> Set[int]:
 def f():
     r0, x :: set
     r1 :: object
-    r2 :: int32
+    r2 :: i32
     r3 :: bit
 L0:
     r0 = PySet_New(0)
@@ -581,7 +581,7 @@ def f() -> Set[int]:
 [out]
 def f():
     r0, x :: set
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
 L0:
     r0 = PySet_New(0)
@@ -612,7 +612,7 @@ def update(s: Set[int], x: List[int]) -> None:
 def update(s, x):
     s :: set
     x :: list
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
 L0:
     r0 = _PySet_Update(s, x)
@@ -627,17 +627,17 @@ def f(x: Set[int], y: Set[int]) -> Set[int]:
 def f(x, y):
     x, y, r0 :: set
     r1 :: object
-    r2 :: int32
+    r2 :: i32
     r3 :: bit
     r4 :: object
-    r5 :: int32
+    r5 :: i32
     r6 :: bit
-    r7 :: int32
+    r7 :: i32
     r8 :: bit
-    r9 :: int32
+    r9 :: i32
     r10 :: bit
     r11 :: object
-    r12 :: int32
+    r12 :: i32
     r13 :: bit
 L0:
     r0 = PySet_New(0)
@@ -672,14 +672,14 @@ def not_precomputed_nested_set(i: int) -> bool:
 def precomputed(i):
     i :: object
     r0 :: set
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
     r3 :: bool
 L0:
     r0 = frozenset({(), (None, (27,)), 1, 2.0, 3, 4j, False, b'bar', 'daylily', 'foo'})
     r1 = PySet_Contains(r0, i)
     r2 = r1 >= 0 :: signed
-    r3 = truncate r1: int32 to builtins.bool
+    r3 = truncate r1: i32 to builtins.bool
     return r3
 def not_precomputed_non_final_name(i):
     i :: int
@@ -689,10 +689,10 @@ def not_precomputed_non_final_name(i):
     r3 :: int
     r4 :: set
     r5 :: object
-    r6 :: int32
+    r6 :: i32
     r7 :: bit
     r8 :: object
-    r9 :: int32
+    r9 :: i32
     r10 :: bit
     r11 :: bool
 L0:
@@ -707,23 +707,23 @@ L0:
     r8 = box(int, i)
     r9 = PySet_Contains(r4, r8)
     r10 = r9 >= 0 :: signed
-    r11 = truncate r9: int32 to builtins.bool
+    r11 = truncate r9: i32 to builtins.bool
     return r11
 def not_precomputed_nested_set(i):
     i :: int
     r0 :: set
     r1 :: object
-    r2 :: int32
+    r2 :: i32
     r3 :: bit
     r4 :: object
     r5 :: set
-    r6 :: int32
+    r6 :: i32
     r7 :: bit
     r8 :: object
-    r9 :: int32
+    r9 :: i32
     r10 :: bit
     r11 :: object
-    r12 :: int32
+    r12 :: i32
     r13 :: bit
     r14 :: bool
 L0:
@@ -741,7 +741,7 @@ L0:
     r11 = box(int, i)
     r12 = PySet_Contains(r5, r11)
     r13 = r12 >= 0 :: signed
-    r14 = truncate r12: int32 to builtins.bool
+    r14 = truncate r12: i32 to builtins.bool
     return r14
 
 [case testForSetLiteral]
@@ -809,7 +809,7 @@ def not_precomputed():
     r3 :: int
     r4 :: set
     r5 :: object
-    r6 :: int32
+    r6 :: i32
     r7 :: bit
     r8, r9 :: object
     r10, not_optimized :: int
diff --git a/mypyc/test-data/irbuild-singledispatch.test b/mypyc/test-data/irbuild-singledispatch.test
index 4e18bbf50d4e2..10970a385966a 100644
--- a/mypyc/test-data/irbuild-singledispatch.test
+++ b/mypyc/test-data/irbuild-singledispatch.test
@@ -16,7 +16,7 @@ def f_obj.__init__(__mypyc_self__):
     __mypyc_self__ :: __main__.f_obj
     r0, r1 :: dict
     r2 :: str
-    r3 :: int32
+    r3 :: i32
     r4 :: bit
 L0:
     r0 = PyDict_New()
@@ -39,7 +39,7 @@ def f_obj.__call__(__mypyc_self__, arg):
     r9 :: object
     r10 :: dict
     r11 :: object
-    r12 :: int32
+    r12 :: i32
     r13 :: bit
     r14 :: object
     r15 :: ptr
@@ -148,7 +148,7 @@ def f_obj.__init__(__mypyc_self__):
     __mypyc_self__ :: __main__.f_obj
     r0, r1 :: dict
     r2 :: str
-    r3 :: int32
+    r3 :: i32
     r4 :: bit
 L0:
     r0 = PyDict_New()
@@ -171,7 +171,7 @@ def f_obj.__call__(__mypyc_self__, x):
     r9 :: object
     r10 :: dict
     r11 :: object
-    r12 :: int32
+    r12 :: i32
     r13 :: bit
     r14 :: object
     r15 :: ptr
diff --git a/mypyc/test-data/irbuild-statements.test b/mypyc/test-data/irbuild-statements.test
index 090c7ed9f3df3..062abd47d163a 100644
--- a/mypyc/test-data/irbuild-statements.test
+++ b/mypyc/test-data/irbuild-statements.test
@@ -651,11 +651,11 @@ def f(l: List[int], t: Tuple[int, ...]) -> None:
 def f(l, t):
     l :: list
     t :: tuple
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
     r2, r3, x :: object
     r4, y :: int
-    r5 :: int32
+    r5 :: i32
     r6 :: bit
     r7, r8 :: object
     r9 :: int
@@ -701,13 +701,13 @@ L2:
     return 2
 def literal_msg(x):
     x :: object
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
     r2, r3 :: bool
 L0:
     r0 = PyObject_IsTrue(x)
     r1 = r0 >= 0 :: signed
-    r2 = truncate r0: int32 to builtins.bool
+    r2 = truncate r0: i32 to builtins.bool
     if r2 goto L2 else goto L1 :: bool
 L1:
     r3 = raise AssertionError('message')
@@ -756,7 +756,7 @@ def delList():
     r3, r4, r5 :: ptr
     l :: list
     r6 :: object
-    r7 :: int32
+    r7 :: i32
     r8 :: bit
 L0:
     r0 = PyList_New(2)
@@ -779,13 +779,13 @@ def delListMultiple():
     r8, r9, r10, r11, r12, r13, r14, r15 :: ptr
     l :: list
     r16 :: object
-    r17 :: int32
+    r17 :: i32
     r18 :: bit
     r19 :: object
-    r20 :: int32
+    r20 :: i32
     r21 :: bit
     r22 :: object
-    r23 :: int32
+    r23 :: i32
     r24 :: bit
 L0:
     r0 = PyList_New(7)
@@ -837,7 +837,7 @@ def delDict():
     r2, r3 :: object
     r4, d :: dict
     r5 :: str
-    r6 :: int32
+    r6 :: i32
     r7 :: bit
 L0:
     r0 = 'one'
@@ -855,9 +855,9 @@ def delDictMultiple():
     r4, r5, r6, r7 :: object
     r8, d :: dict
     r9, r10 :: str
-    r11 :: int32
+    r11 :: i32
     r12 :: bit
-    r13 :: int32
+    r13 :: i32
     r14 :: bit
 L0:
     r0 = 'one'
@@ -901,7 +901,7 @@ L0:
 def delAttribute():
     r0, dummy :: __main__.Dummy
     r1 :: str
-    r2 :: int32
+    r2 :: i32
     r3 :: bit
 L0:
     r0 = Dummy(2, 4)
@@ -913,10 +913,10 @@ L0:
 def delAttributeMultiple():
     r0, dummy :: __main__.Dummy
     r1 :: str
-    r2 :: int32
+    r2 :: i32
     r3 :: bit
     r4 :: str
-    r5 :: int32
+    r5 :: i32
     r6 :: bit
 L0:
     r0 = Dummy(2, 4)
@@ -1029,7 +1029,7 @@ def f(a, b):
     r6, r7 :: object
     r8, x :: int
     r9, y :: bool
-    r10 :: int32
+    r10 :: i32
     r11 :: bit
     r12 :: bool
     r13 :: short_int
@@ -1055,7 +1055,7 @@ L3:
     y = r9
     r10 = PyObject_IsTrue(b)
     r11 = r10 >= 0 :: signed
-    r12 = truncate r10: int32 to builtins.bool
+    r12 = truncate r10: i32 to builtins.bool
     if r12 goto L4 else goto L5 :: bool
 L4:
     x = 2
diff --git a/mypyc/test-data/irbuild-str.test b/mypyc/test-data/irbuild-str.test
index 63be7250ebd10..9851e0f4fb24d 100644
--- a/mypyc/test-data/irbuild-str.test
+++ b/mypyc/test-data/irbuild-str.test
@@ -65,7 +65,7 @@ def neq(x: str, y: str) -> bool:
 [out]
 def eq(x, y):
     x, y :: str
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
     r2 :: object
     r3, r4, r5 :: bit
@@ -84,7 +84,7 @@ L3:
     return r5
 def neq(x, y):
     x, y :: str
-    r0 :: int32
+    r0 :: i32
     r1 :: bit
     r2 :: object
     r3, r4, r5 :: bit
diff --git a/mypyc/test-data/irbuild-try.test b/mypyc/test-data/irbuild-try.test
index faf3fa1dbd2f0..a5b7b9a55b868 100644
--- a/mypyc/test-data/irbuild-try.test
+++ b/mypyc/test-data/irbuild-try.test
@@ -337,7 +337,7 @@ def foo(x):
     r11, r12 :: object
     r13, r14 :: tuple[object, object, object]
     r15, r16, r17, r18 :: object
-    r19 :: int32
+    r19 :: i32
     r20 :: bit
     r21 :: bool
     r22 :: bit
@@ -372,7 +372,7 @@ L3: (handler for L2)
     r18 = PyObject_CallFunctionObjArgs(r3, r0, r15, r16, r17, 0)
     r19 = PyObject_IsTrue(r18)
     r20 = r19 >= 0 :: signed
-    r21 = truncate r19: int32 to builtins.bool
+    r21 = truncate r19: i32 to builtins.bool
     if r21 goto L5 else goto L4 :: bool
 L4:
     CPy_Reraise()
@@ -448,7 +448,7 @@ def foo(x):
     r9, r10, r11 :: object
     r12 :: None
     r13 :: object
-    r14 :: int32
+    r14 :: i32
     r15 :: bit
     r16 :: bool
     r17 :: bit
@@ -478,7 +478,7 @@ L3: (handler for L2)
     r13 = box(None, r12)
     r14 = PyObject_IsTrue(r13)
     r15 = r14 >= 0 :: signed
-    r16 = truncate r14: int32 to builtins.bool
+    r16 = truncate r14: i32 to builtins.bool
     if r16 goto L5 else goto L4 :: bool
 L4:
     CPy_Reraise()
diff --git a/mypyc/test-data/irbuild-tuple.test b/mypyc/test-data/irbuild-tuple.test
index 6a86a6c6781b9..a47f3db6a7254 100644
--- a/mypyc/test-data/irbuild-tuple.test
+++ b/mypyc/test-data/irbuild-tuple.test
@@ -103,7 +103,7 @@ def f(x, y):
     r1, r2 :: object
     r3, r4, r5 :: ptr
     r6, r7, r8 :: object
-    r9 :: int32
+    r9 :: i32
     r10 :: bit
     r11 :: tuple
 L0:
diff --git a/mypyc/test-data/irbuild-u8.test b/mypyc/test-data/irbuild-u8.test
new file mode 100644
index 0000000000000..14f691c9451f2
--- /dev/null
+++ b/mypyc/test-data/irbuild-u8.test
@@ -0,0 +1,543 @@
+# Test cases for u8 native ints. Focus on things that are different from i64; no need to
+# duplicate all i64 test cases here.
+
+[case testU8BinaryOp]
+from mypy_extensions import u8
+
+def add_op(x: u8, y: u8) -> u8:
+    x = y + x
+    y = x + 5
+    y += x
+    y += 7
+    x = 5 + y
+    return x
+def compare(x: u8, y: u8) -> None:
+    a = x == y
+    b = x == 5
+    c = x < y
+    d = x < 5
+    e = 5 == x
+    f = 5 < x
+[out]
+def add_op(x, y):
+    x, y, r0, r1, r2, r3, r4 :: u8
+L0:
+    r0 = y + x
+    x = r0
+    r1 = x + 5
+    y = r1
+    r2 = y + x
+    y = r2
+    r3 = y + 7
+    y = r3
+    r4 = 5 + y
+    x = r4
+    return x
+def compare(x, y):
+    x, y :: u8
+    r0 :: bit
+    a :: bool
+    r1 :: bit
+    b :: bool
+    r2 :: bit
+    c :: bool
+    r3 :: bit
+    d :: bool
+    r4 :: bit
+    e :: bool
+    r5 :: bit
+    f :: bool
+L0:
+    r0 = x == y
+    a = r0
+    r1 = x == 5
+    b = r1
+    r2 = x < y :: unsigned
+    c = r2
+    r3 = x < 5 :: unsigned
+    d = r3
+    r4 = 5 == x
+    e = r4
+    r5 = 5 < x :: unsigned
+    f = r5
+    return 1
+
+[case testU8UnaryOp]
+from mypy_extensions import u8
+
+def unary(x: u8) -> u8:
+    y = -x
+    x = ~y
+    y = +x
+    return y
+[out]
+def unary(x):
+    x, r0, y, r1 :: u8
+L0:
+    r0 = 0 - x
+    y = r0
+    r1 = y ^ 255
+    x = r1
+    y = x
+    return y
+
+[case testU8DivisionByConstant]
+from mypy_extensions import u8
+
+def div_by_constant(x: u8) -> u8:
+    x = x // 5
+    x //= 17
+    return x
+[out]
+def div_by_constant(x):
+    x, r0, r1 :: u8
+L0:
+    r0 = x / 5
+    x = r0
+    r1 = x / 17
+    x = r1
+    return x
+
+[case testU8ModByConstant]
+from mypy_extensions import u8
+
+def mod_by_constant(x: u8) -> u8:
+    x = x % 5
+    x %= 17
+    return x
+[out]
+def mod_by_constant(x):
+    x, r0, r1 :: u8
+L0:
+    r0 = x % 5
+    x = r0
+    r1 = x % 17
+    x = r1
+    return x
+
+[case testU8DivModByVariable]
+from mypy_extensions import u8
+
+def divmod(x: u8, y: u8) -> u8:
+    a = x // y
+    return a % y
+[out]
+def divmod(x, y):
+    x, y :: u8
+    r0 :: bit
+    r1 :: bool
+    r2, a :: u8
+    r3 :: bit
+    r4 :: bool
+    r5 :: u8
+L0:
+    r0 = y == 0
+    if r0 goto L1 else goto L2 :: bool
+L1:
+    r1 = raise ZeroDivisionError('integer division or modulo by zero')
+    unreachable
+L2:
+    r2 = x / y
+    a = r2
+    r3 = y == 0
+    if r3 goto L3 else goto L4 :: bool
+L3:
+    r4 = raise ZeroDivisionError('integer division or modulo by zero')
+    unreachable
+L4:
+    r5 = a % y
+    return r5
+
+[case testU8BinaryOperationWithOutOfRangeOperand]
+from mypy_extensions import u8
+
+def out_of_range(x: u8) -> None:
+    x + (-1)
+    (-2) + x
+    x * 256
+    -1 < x
+    x > -5
+    x == 1000
+    x + 255  # OK
+    255 + x   # OK
+[out]
+main:4: error: Value -1 is out of range for "u8"
+main:5: error: Value -2 is out of range for "u8"
+main:6: error: Value 256 is out of range for "u8"
+main:7: error: Value -1 is out of range for "u8"
+main:8: error: Value -5 is out of range for "u8"
+main:9: error: Value 1000 is out of range for "u8"
+
+[case testU8DetectMoreOutOfRangeLiterals]
+from mypy_extensions import u8
+
+def out_of_range() -> None:
+    a: u8 = 256
+    b: u8 = -1
+    f(256)
+    # The following are ok
+    c: u8 = 0
+    d: u8 = 255
+    f(0)
+    f(255)
+
+def f(x: u8) -> None: pass
+[out]
+main:4: error: Value 256 is out of range for "u8"
+main:5: error: Value -1 is out of range for "u8"
+main:6: error: Value 256 is out of range for "u8"
+
+[case testU8BoxAndUnbox]
+from typing import Any
+from mypy_extensions import u8
+
+def f(x: Any) -> Any:
+    y: u8 = x
+    return y
+[out]
+def f(x):
+    x :: object
+    r0, y :: u8
+    r1 :: object
+L0:
+    r0 = unbox(u8, x)
+    y = r0
+    r1 = box(u8, y)
+    return r1
+
+[case testU8MixedCompare1]
+from mypy_extensions import u8
+def f(x: int, y: u8) -> bool:
+    return x == y
+[out]
+def f(x, y):
+    x :: int
+    y :: u8
+    r0 :: native_int
+    r1, r2, r3 :: bit
+    r4 :: native_int
+    r5, r6 :: u8
+    r7 :: bit
+L0:
+    r0 = x & 1
+    r1 = r0 == 0
+    if r1 goto L1 else goto L4 :: bool
+L1:
+    r2 = x < 512 :: signed
+    if r2 goto L2 else goto L4 :: bool
+L2:
+    r3 = x >= 0 :: signed
+    if r3 goto L3 else goto L4 :: bool
+L3:
+    r4 = x >> 1
+    r5 = truncate r4: native_int to u8
+    r6 = r5
+    goto L5
+L4:
+    CPyUInt8_Overflow()
+    unreachable
+L5:
+    r7 = r6 == y
+    return r7
+
+[case testU8MixedCompare2]
+from mypy_extensions import u8
+def f(x: u8, y: int) -> bool:
+    return x == y
+[out]
+def f(x, y):
+    x :: u8
+    y :: int
+    r0 :: native_int
+    r1, r2, r3 :: bit
+    r4 :: native_int
+    r5, r6 :: u8
+    r7 :: bit
+L0:
+    r0 = y & 1
+    r1 = r0 == 0
+    if r1 goto L1 else goto L4 :: bool
+L1:
+    r2 = y < 512 :: signed
+    if r2 goto L2 else goto L4 :: bool
+L2:
+    r3 = y >= 0 :: signed
+    if r3 goto L3 else goto L4 :: bool
+L3:
+    r4 = y >> 1
+    r5 = truncate r4: native_int to u8
+    r6 = r5
+    goto L5
+L4:
+    CPyUInt8_Overflow()
+    unreachable
+L5:
+    r7 = x == r6
+    return r7
+
+[case testU8ConvertToInt]
+from mypy_extensions import u8
+
+def u8_to_int(a: u8) -> int:
+    return a
+[out]
+def u8_to_int(a):
+    a :: u8
+    r0 :: native_int
+    r1 :: int
+L0:
+    r0 = extend a: u8 to native_int
+    r1 = r0 << 1
+    return r1
+
+[case testU8OperatorAssignmentMixed]
+from mypy_extensions import u8
+
+def f(a: u8) -> None:
+    x = 0
+    x += a
+[out]
+def f(a):
+    a :: u8
+    x :: int
+    r0 :: native_int
+    r1, r2, r3 :: bit
+    r4 :: native_int
+    r5, r6, r7 :: u8
+    r8 :: native_int
+    r9 :: int
+L0:
+    x = 0
+    r0 = x & 1
+    r1 = r0 == 0
+    if r1 goto L1 else goto L4 :: bool
+L1:
+    r2 = x < 512 :: signed
+    if r2 goto L2 else goto L4 :: bool
+L2:
+    r3 = x >= 0 :: signed
+    if r3 goto L3 else goto L4 :: bool
+L3:
+    r4 = x >> 1
+    r5 = truncate r4: native_int to u8
+    r6 = r5
+    goto L5
+L4:
+    CPyUInt8_Overflow()
+    unreachable
+L5:
+    r7 = r6 + a
+    r8 = extend r7: u8 to native_int
+    r9 = r8 << 1
+    x = r9
+    return 1
+
+[case testU8InitializeFromLiteral]
+from mypy_extensions import u8, i64
+
+def f() -> None:
+    x: u8 = 0
+    y: u8 = 255
+    z: u8 = 5 + 7
+[out]
+def f():
+    x, y, z :: u8
+L0:
+    x = 0
+    y = 255
+    z = 12
+    return 1
+
+[case testU8ExplicitConversionFromNativeInt]
+from mypy_extensions import i64, i32, i16, u8
+
+def from_u8(x: u8) -> u8:
+    return u8(x)
+
+def from_i16(x: i16) -> u8:
+    return u8(x)
+
+def from_i32(x: i32) -> u8:
+    return u8(x)
+
+def from_i64(x: i64) -> u8:
+    return u8(x)
+[out]
+def from_u8(x):
+    x :: u8
+L0:
+    return x
+def from_i16(x):
+    x :: i16
+    r0 :: u8
+L0:
+    r0 = truncate x: i16 to u8
+    return r0
+def from_i32(x):
+    x :: i32
+    r0 :: u8
+L0:
+    r0 = truncate x: i32 to u8
+    return r0
+def from_i64(x):
+    x :: i64
+    r0 :: u8
+L0:
+    r0 = truncate x: i64 to u8
+    return r0
+
+[case testU8ExplicitConversionToNativeInt]
+from mypy_extensions import i64, i32, i16, u8
+
+def to_i16(x: u8) -> i16:
+    return i16(x)
+
+def to_i32(x: u8) -> i32:
+    return i32(x)
+
+def to_i64(x: u8) -> i64:
+    return i64(x)
+[out]
+def to_i16(x):
+    x :: u8
+    r0 :: i16
+L0:
+    r0 = extend x: u8 to i16
+    return r0
+def to_i32(x):
+    x :: u8
+    r0 :: i32
+L0:
+    r0 = extend x: u8 to i32
+    return r0
+def to_i64(x):
+    x :: u8
+    r0 :: i64
+L0:
+    r0 = extend x: u8 to i64
+    return r0
+
+[case testU8ExplicitConversionFromInt]
+from mypy_extensions import u8
+
+def f(x: int) -> u8:
+    return u8(x)
+[out]
+def f(x):
+    x :: int
+    r0 :: native_int
+    r1, r2, r3 :: bit
+    r4 :: native_int
+    r5, r6 :: u8
+L0:
+    r0 = x & 1
+    r1 = r0 == 0
+    if r1 goto L1 else goto L4 :: bool
+L1:
+    r2 = x < 512 :: signed
+    if r2 goto L2 else goto L4 :: bool
+L2:
+    r3 = x >= 0 :: signed
+    if r3 goto L3 else goto L4 :: bool
+L3:
+    r4 = x >> 1
+    r5 = truncate r4: native_int to u8
+    r6 = r5
+    goto L5
+L4:
+    CPyUInt8_Overflow()
+    unreachable
+L5:
+    return r6
+
+[case testU8ExplicitConversionFromLiteral]
+from mypy_extensions import u8
+
+def f() -> None:
+    x = u8(0)
+    y = u8(11)
+    z = u8(-3)  # Truncate
+    zz = u8(258)  # Truncate
+    a = u8(255)
+[out]
+def f():
+    x, y, z, zz, a :: u8
+L0:
+    x = 0
+    y = 11
+    z = 253
+    zz = 2
+    a = 255
+    return 1
+
+[case testU8ExplicitConversionFromVariousTypes]
+from mypy_extensions import u8
+
+def bool_to_u8(b: bool) -> u8:
+    return u8(b)
+
+def str_to_u8(s: str) -> u8:
+    return u8(s)
+
+class C:
+    def __int__(self) -> u8:
+        return 5
+
+def instance_to_u8(c: C) -> u8:
+    return u8(c)
+
+def float_to_u8(x: float) -> u8:
+    return u8(x)
+[out]
+def bool_to_u8(b):
+    b :: bool
+    r0 :: u8
+L0:
+    r0 = extend b: builtins.bool to u8
+    return r0
+def str_to_u8(s):
+    s :: str
+    r0 :: object
+    r1 :: u8
+L0:
+    r0 = CPyLong_FromStr(s)
+    r1 = unbox(u8, r0)
+    return r1
+def C.__int__(self):
+    self :: __main__.C
+L0:
+    return 5
+def instance_to_u8(c):
+    c :: __main__.C
+    r0 :: u8
+L0:
+    r0 = c.__int__()
+    return r0
+def float_to_u8(x):
+    x :: float
+    r0 :: int
+    r1 :: native_int
+    r2, r3, r4 :: bit
+    r5 :: native_int
+    r6, r7 :: u8
+L0:
+    r0 = CPyTagged_FromFloat(x)
+    r1 = r0 & 1
+    r2 = r1 == 0
+    if r2 goto L1 else goto L4 :: bool
+L1:
+    r3 = r0 < 512 :: signed
+    if r3 goto L2 else goto L4 :: bool
+L2:
+    r4 = r0 >= 0 :: signed
+    if r4 goto L3 else goto L4 :: bool
+L3:
+    r5 = r0 >> 1
+    r6 = truncate r5: native_int to u8
+    r7 = r6
+    goto L5
+L4:
+    CPyUInt8_Overflow()
+    unreachable
+L5:
+    return r7
diff --git a/mypyc/test-data/irbuild-unreachable.test b/mypyc/test-data/irbuild-unreachable.test
index 2c164491a5a12..1c024a249bf1c 100644
--- a/mypyc/test-data/irbuild-unreachable.test
+++ b/mypyc/test-data/irbuild-unreachable.test
@@ -11,7 +11,7 @@ def f():
     r1 :: str
     r2 :: object
     r3, r4 :: str
-    r5 :: int32
+    r5 :: i32
     r6 :: bit
     r7 :: object
     r8, r9, r10 :: bit
@@ -68,7 +68,7 @@ def f():
     r1 :: str
     r2 :: object
     r3, r4 :: str
-    r5 :: int32
+    r5 :: i32
     r6 :: bit
     r7 :: object
     r8, r9, r10 :: bit
diff --git a/mypyc/test-data/refcount.test b/mypyc/test-data/refcount.test
index 372956a00cabb..3db4caa395665 100644
--- a/mypyc/test-data/refcount.test
+++ b/mypyc/test-data/refcount.test
@@ -702,7 +702,7 @@ def f(a, x):
     a :: list
     x :: int
     r0 :: object
-    r1 :: int32
+    r1 :: i32
     r2 :: bit
 L0:
     inc_ref x :: int
@@ -1504,10 +1504,10 @@ def f(x):
     x, r0 :: int
     r1 :: native_int
     r2 :: bit
-    r3, r4 :: int64
+    r3, r4 :: i64
     r5 :: ptr
     r6 :: c_ptr
-    r7 :: int64
+    r7 :: i64
 L0:
     r0 = CPyTagged_Add(x, 2)
     r1 = r0 & 1
diff --git a/mypyc/test-data/run-u8.test b/mypyc/test-data/run-u8.test
new file mode 100644
index 0000000000000..cddb031e33524
--- /dev/null
+++ b/mypyc/test-data/run-u8.test
@@ -0,0 +1,303 @@
+[case testU8BasicOps]
+from typing import Any, Tuple
+
+from mypy_extensions import u8, i16, i32, i64
+from typing_extensions import Final
+
+from testutil import assertRaises
+
+ERROR: Final = 239
+
+def test_box_and_unbox() -> None:
+    for i in range(0, 256):
+        o: Any = i
+        x: u8 = o
+        o2: Any = x
+        assert o == o2
+        assert x == i
+    with assertRaises(OverflowError, "int too large or small to convert to u8"):
+        o = 256
+        x2: u8 = o
+    with assertRaises(OverflowError, "int too large or small to convert to u8"):
+        o = -1
+        x3: u8 = o
+
+def div_by_7(x: u8) -> u8:
+    return x // 7
+
+def div(x: u8, y: u8) -> u8:
+    return x // y
+
+def test_divide_by_constant() -> None:
+    for i in range(0, 256):
+        assert div_by_7(i) == i // 7
+
+def test_divide_by_variable() -> None:
+    for x in range(0, 256):
+        for y in range(0, 256):
+            if y != 0:
+                assert div(x, y) == x // y
+            else:
+                with assertRaises(ZeroDivisionError, "integer division or modulo by zero"):
+                    div(x, y)
+
+def mod_by_7(x: u8) -> u8:
+    return x % 7
+
+def mod(x: u8, y: u8) -> u8:
+    return x % y
+
+def test_mod_by_constant() -> None:
+    for i in range(0, 256):
+        assert mod_by_7(i) == i % 7
+
+def test_mod_by_variable() -> None:
+    for x in range(0, 256):
+        for y in range(0, 256):
+            if y != 0:
+                assert mod(x, y) == x % y
+            else:
+                with assertRaises(ZeroDivisionError, "integer division or modulo by zero"):
+                    mod(x, y)
+
+def test_simple_arithmetic_ops() -> None:
+    zero: u8 = int()
+    one: u8 = zero + 1
+    two: u8 = one + 1
+    neg_one: u8 = -one
+    assert neg_one == 255
+    assert one + one == 2
+    assert one + two == 3
+    assert one + neg_one == 0
+    assert one - one == 0
+    assert one - two == 255
+    assert one * one == 1
+    assert one * two == 2
+    assert two * two == 4
+    assert two * neg_one == 254
+    assert neg_one * one == 255
+    assert neg_one * neg_one == 1
+    assert two * 0 == 0
+    assert 0 * two == 0
+    assert -one == 255
+    assert -two == 254
+    assert -neg_one == 1
+    assert -zero == 0
+
+def test_bitwise_ops() -> None:
+    x: u8 = 184 + int()
+    y: u8 = 79 + int()
+    z: u8 = 113 + int()
+    zero: u8 = int()
+    one: u8 = zero + 1
+    two: u8 = zero + 2
+    neg_one: u8 = -one
+
+    assert x & y == 8
+    assert x & z == 48
+    assert z & z == z
+    assert x & zero == 0
+
+    assert x | y == 255
+    assert x | z == 249
+    assert z | z == z
+    assert x | 0 == x
+
+    assert x ^ y == 247
+    assert x ^ z == 201
+    assert z ^ z == 0
+    assert z ^ 0 == z
+
+    assert x << one == 112
+    assert x << two == 224
+    assert z << two == 196
+    assert z << 0 == z
+
+    assert x >> one == 92
+    assert x >> two == 46
+    assert z >> two == 28
+    assert z >> 0 == z
+
+    for i in range(256):
+        t: u8 = i
+        assert ~t == (~(i + int()) & 0xff)
+
+def eq(x: u8, y: u8) -> bool:
+    return x == y
+
+def test_eq() -> None:
+    assert eq(int(), int())
+    assert eq(5 + int(), 5 + int())
+    assert not eq(int(), 1 + int())
+    assert not eq(5 + int(), 6 + int())
+
+def test_comparisons() -> None:
+    one: u8 = 1 + int()
+    one2: u8 = 1 + int()
+    two: u8 = 2 + int()
+    assert one < two
+    assert not (one < one2)
+    assert not (two < one)
+    assert two > one
+    assert not (one > one2)
+    assert not (one > two)
+    assert one <= two
+    assert one <= one2
+    assert not (two <= one)
+    assert two >= one
+    assert one >= one2
+    assert not (one >= two)
+    assert one == one2
+    assert not (one == two)
+    assert one != two
+    assert not (one != one2)
+
+def test_mixed_comparisons() -> None:
+    u8_3: u8 = int() + 3
+    int_5 = int() + 5
+    assert u8_3 < int_5
+    assert int_5 > u8_3
+    b = u8_3 > int_5
+    assert not b
+
+    int_largest = int() + 255
+    assert int_largest > u8_3
+    int_smallest = int()
+    assert u8_3 > int_smallest
+
+    int_too_big = int() + 256
+    int_too_small = int() -1
+    with assertRaises(OverflowError):
+        assert u8_3 < int_too_big
+    with assertRaises(OverflowError):
+        assert int_too_big < u8_3
+    with assertRaises(OverflowError):
+        assert u8_3 > int_too_small
+    with assertRaises(OverflowError):
+        assert int_too_small < u8_3
+
+def test_mixed_arithmetic_and_bitwise_ops() -> None:
+    u8_3: u8 = int() + 3
+    int_5 = int() + 5
+    assert u8_3 + int_5 == 8
+    assert int_5 - u8_3 == 2
+    assert u8_3 << int_5 == 96
+    assert int_5 << u8_3  == 40
+    assert u8_3 ^ int_5 == 6
+    assert int_5 | u8_3  == 7
+
+    int_largest = int() + 255
+    assert int_largest - u8_3 == 252
+    int_smallest = int()
+    assert int_smallest + u8_3 == 3
+
+    int_too_big = int() + 256
+    int_too_small = int() - 1
+    with assertRaises(OverflowError):
+        assert u8_3 & int_too_big
+    with assertRaises(OverflowError):
+        assert int_too_small & u8_3
+
+def test_coerce_to_and_from_int() -> None:
+    for n in range(0, 256):
+        x: u8 = n
+        m: int = x
+        assert m == n
+
+def test_explicit_conversion_to_u8() -> None:
+    x = u8(5)
+    assert x == 5
+    y = int() + ERROR
+    x = u8(y)
+    assert x == ERROR
+    n64: i64 = 233
+    x = u8(n64)
+    assert x == 233
+    n32: i32 = 234
+    x = u8(n32)
+    assert x == 234
+    z = u8(x)
+    assert z == 234
+    n16: i16 = 231
+    x = u8(n16)
+    assert x == 231
+
+def test_explicit_conversion_overflow() -> None:
+    max_u8 = int() + 255
+    x = u8(max_u8)
+    assert x == 255
+    assert int(x) == max_u8
+
+    min_u8 = int()
+    y = u8(min_u8)
+    assert y == 0
+    assert int(y) == min_u8
+
+    too_big = int() + 256
+    with assertRaises(OverflowError):
+        x = u8(too_big)
+
+    too_small = int() - 1
+    with assertRaises(OverflowError):
+        x = u8(too_small)
+
+def test_u8_from_large_small_literal() -> None:
+    x = u8(255) # XXX u8(2**15 - 1)
+    assert x == 255
+    x = u8(0)
+    assert x == 0
+
+def test_u8_truncate_from_i64() -> None:
+    large = i64(2**32 + 256 + 157 + int())
+    x = u8(large)
+    assert x == 157
+    small = i64(-2**32 - 256 - 157 + int())
+    x = u8(small)
+    assert x == 256 - 157
+    large2 = i64(2**8 + int())
+    x = u8(large2)
+    assert x == 0
+    small2 = i64(-2**8 - 1 - int())
+    x = u8(small2)
+    assert x == 255
+
+def test_u8_truncate_from_i32() -> None:
+    large = i32(2**16 + 2**8 + 5 + int())
+    assert u8(large) == 5
+    small = i32(-2**16 - 2**8 - 1 + int())
+    assert u8(small) == 255
+
+def from_float(x: float) -> u8:
+    return u8(x)
+
+def test_explicit_conversion_from_float() -> None:
+    assert from_float(0.0) == 0
+    assert from_float(1.456) == 1
+    assert from_float(234.567) == 234
+    assert from_float(255) == 255
+    assert from_float(0) == 0
+    assert from_float(-0.999) == 0
+    # The error message could be better, but this is acceptable
+    with assertRaises(OverflowError, "int too large or small to convert to u8"):
+        assert from_float(float(256))
+    with assertRaises(OverflowError, "int too large or small to convert to u8"):
+        # One ulp below the lowest valid i64 value
+        from_float(float(-1.0))
+
+def test_tuple_u8() -> None:
+    a: u8 = 1
+    b: u8 = 2
+    t = (a, b)
+    a, b = t
+    assert a == 1
+    assert b == 2
+    x: Any = t
+    tt: Tuple[u8, u8] = x
+    assert tt == (1, 2)
+
+def test_convert_u8_to_native_int() -> None:
+    for i in range(256):
+        x: u8 = i
+        assert i16(x) == i
+        assert i32(x) == i
+        assert i64(x) == i
diff --git a/mypyc/test/test_irbuild.py b/mypyc/test/test_irbuild.py
index 2b14619a9884f..5b3f678d8f173 100644
--- a/mypyc/test/test_irbuild.py
+++ b/mypyc/test/test_irbuild.py
@@ -43,6 +43,7 @@
     "irbuild-i64.test",
     "irbuild-i32.test",
     "irbuild-i16.test",
+    "irbuild-u8.test",
     "irbuild-vectorcall.test",
     "irbuild-unreachable.test",
     "irbuild-isinstance.test",
diff --git a/mypyc/test/test_ircheck.py b/mypyc/test/test_ircheck.py
index 008963642272b..7f7063cdc5e60 100644
--- a/mypyc/test/test_ircheck.py
+++ b/mypyc/test/test_ircheck.py
@@ -117,7 +117,7 @@ def test_invalid_return_type(self) -> None:
             blocks=[self.basic_block([ret])],
         )
         assert_has_error(
-            fn, FnError(source=ret, desc="Cannot coerce source type int32 to dest type int64")
+            fn, FnError(source=ret, desc="Cannot coerce source type i32 to dest type i64")
         )
 
     def test_invalid_assign(self) -> None:
@@ -130,7 +130,7 @@ def test_invalid_assign(self) -> None:
             blocks=[self.basic_block([assign, ret])],
         )
         assert_has_error(
-            fn, FnError(source=assign, desc="Cannot coerce source type int32 to dest type int64")
+            fn, FnError(source=assign, desc="Cannot coerce source type i32 to dest type i64")
         )
 
     def test_can_coerce_to(self) -> None:
diff --git a/mypyc/test/test_run.py b/mypyc/test/test_run.py
index 2dd1c025123f8..df9d44eab73fa 100644
--- a/mypyc/test/test_run.py
+++ b/mypyc/test/test_run.py
@@ -42,6 +42,7 @@
     "run-i64.test",
     "run-i32.test",
     "run-i16.test",
+    "run-u8.test",
     "run-floats.test",
     "run-math.test",
     "run-bools.test",
diff --git a/mypyc/test/test_struct.py b/mypyc/test/test_struct.py
index 2b0298cadeda7..82990e6afd828 100644
--- a/mypyc/test/test_struct.py
+++ b/mypyc/test/test_struct.py
@@ -55,8 +55,8 @@ def test_struct_str(self) -> None:
             "b:<RPrimitive builtins.object>}>"
         )
         r1 = RStruct("Bar", ["c"], [int32_rprimitive])
-        assert str(r1) == "Bar{c:int32}"
-        assert repr(r1) == "<RStruct Bar{c:<RPrimitive int32>}>"
+        assert str(r1) == "Bar{c:i32}"
+        assert repr(r1) == "<RStruct Bar{c:<RPrimitive i32>}>"
         r2 = RStruct("Baz", [], [])
         assert str(r2) == "Baz{}"
         assert repr(r2) == "<RStruct Baz{}>"
diff --git a/test-data/unit/lib-stub/mypy_extensions.pyi b/test-data/unit/lib-stub/mypy_extensions.pyi
index b7ff010643158..4295c33f81ade 100644
--- a/test-data/unit/lib-stub/mypy_extensions.pyi
+++ b/test-data/unit/lib-stub/mypy_extensions.pyi
@@ -50,7 +50,37 @@ class FlexibleAlias(Generic[_T, _U]): ...
 class __SupportsInt(Protocol[T_co]):
     def __int__(self) -> int: pass
 
-_Int = Union[int, i16, i32, i64]
+_Int = Union[int, u8, i16, i32, i64]
+
+class u8:
+    def __init__(self, x: Union[_Int, str, bytes, SupportsInt], base: int = 10) -> None: ...
+    def __add__(self, x: u8) -> u8: ...
+    def __radd__(self, x: u8) -> u8: ...
+    def __sub__(self, x: u8) -> u8: ...
+    def __rsub__(self, x: u8) -> u8: ...
+    def __mul__(self, x: u8) -> u8: ...
+    def __rmul__(self, x: u8) -> u8: ...
+    def __floordiv__(self, x: u8) -> u8: ...
+    def __rfloordiv__(self, x: u8) -> u8: ...
+    def __mod__(self, x: u8) -> u8: ...
+    def __rmod__(self, x: u8) -> u8: ...
+    def __and__(self, x: u8) -> u8: ...
+    def __rand__(self, x: u8) -> u8: ...
+    def __or__(self, x: u8) -> u8: ...
+    def __ror__(self, x: u8) -> u8: ...
+    def __xor__(self, x: u8) -> u8: ...
+    def __rxor__(self, x: u8) -> u8: ...
+    def __lshift__(self, x: u8) -> u8: ...
+    def __rlshift__(self, x: u8) -> u8: ...
+    def __rshift__(self, x: u8) -> u8: ...
+    def __rrshift__(self, x: u8) -> u8: ...
+    def __neg__(self) -> u8: ...
+    def __invert__(self) -> u8: ...
+    def __pos__(self) -> u8: ...
+    def __lt__(self, x: u8) -> bool: ...
+    def __le__(self, x: u8) -> bool: ...
+    def __ge__(self, x: u8) -> bool: ...
+    def __gt__(self, x: u8) -> bool: ...
 
 class i16:
     def __init__(self, x: Union[_Int, str, bytes, SupportsInt], base: int = 10) -> None: ...

From 79114d19df14b28effc8bbd7cb376521d83b0046 Mon Sep 17 00:00:00 2001
From: Jukka Lehtosalo <jukka.lehtosalo@iki.fi>
Date: Thu, 6 Jul 2023 18:09:57 +0100
Subject: [PATCH 123/129] [mypyc] Fix multiple inheritance with a protocol on
 Python 3.12 (#15572)

Fix the testProtocol test case in mypyc/test-data/run-classes.test.

There was a comment indicating that the code that causes the test to
fail on 3.12 is required Python versions older than 3.7, so let's remove
it. We only support 3.8 and later these days.

Work on https://github.com/mypyc/mypyc/issues/995.
---
 mypyc/lib-rt/misc_ops.c | 36 ------------------------------------
 1 file changed, 36 deletions(-)

diff --git a/mypyc/lib-rt/misc_ops.c b/mypyc/lib-rt/misc_ops.c
index 88a76fb210d7a..f28eeb57e6467 100644
--- a/mypyc/lib-rt/misc_ops.c
+++ b/mypyc/lib-rt/misc_ops.c
@@ -177,42 +177,6 @@ PyObject *CPyType_FromTemplate(PyObject *template,
     if (!name)
         goto error;
 
-    // If there is a metaclass other than type, we would like to call
-    // its __new__ function. Unfortunately there doesn't seem to be a
-    // good way to mix a C extension class and creating it via a
-    // metaclass. We need to do it anyways, though, in order to
-    // support subclassing Generic[T] prior to Python 3.7.
-    //
-    // We solve this with a kind of atrocious hack: create a parallel
-    // class using the metaclass, determine the bases of the real
-    // class by pulling them out of the parallel class, creating the
-    // real class, and then merging its dict back into the original
-    // class. There are lots of cases where this won't really work,
-    // but for the case of GenericMeta setting a bunch of properties
-    // on the class we should be fine.
-    if (metaclass != &PyType_Type) {
-        assert(bases && "non-type metaclasses require non-NULL bases");
-
-        PyObject *ns = PyDict_New();
-        if (!ns)
-            goto error;
-
-        if (bases != orig_bases) {
-            if (PyDict_SetItemString(ns, "__orig_bases__", orig_bases) < 0)
-                goto error;
-        }
-
-        dummy_class = (PyTypeObject *)PyObject_CallFunctionObjArgs(
-            (PyObject *)metaclass, name, bases, ns, NULL);
-        Py_DECREF(ns);
-        if (!dummy_class)
-            goto error;
-
-        Py_DECREF(bases);
-        bases = dummy_class->tp_bases;
-        Py_INCREF(bases);
-    }
-
     // Allocate the type and then copy the main stuff in.
     t = (PyHeapTypeObject*)PyType_GenericAlloc(&PyType_Type, 0);
     if (!t)

From cf863877aac1e1b54a929aca08125bfdcd4bf8f9 Mon Sep 17 00:00:00 2001
From: Stavros Ntentos <133706+stdedos@users.noreply.github.com>
Date: Thu, 6 Jul 2023 22:12:34 +0300
Subject: [PATCH 124/129] "mypy Gitter" is dead; it is called "python/typing"
 (#15610)

---
 .github/ISSUE_TEMPLATE/config.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
index 64a2e6494c1b1..a88773308d5e6 100644
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -2,6 +2,6 @@ contact_links:
   - about: "Please check the linked documentation page before filing new issues."
     name: "Common issues and solutions"
     url: "https://mypy.readthedocs.io/en/stable/common_issues.html"
-  - about: "Please ask and answer any questions on the mypy Gitter."
+  - about: "Please ask and answer any questions on the python/typing Gitter."
     name: "Questions or Chat"
     url: "https://gitter.im/python/typing"

From d65e1e7523a30323a617ecb55cde8a9ed89e653a Mon Sep 17 00:00:00 2001
From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
Date: Fri, 7 Jul 2023 00:04:20 +0200
Subject: [PATCH 125/129] Add upper bound for lxml (#15608)

---
 test-requirements.txt | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test-requirements.txt b/test-requirements.txt
index 6611878233689..195909b71b8d8 100644
--- a/test-requirements.txt
+++ b/test-requirements.txt
@@ -3,7 +3,8 @@
 attrs>=18.0
 black==23.3.0  # must match version in .pre-commit-config.yaml
 filelock>=3.3.0
-lxml>=4.9.1; (python_version<'3.11' or sys_platform!='win32') and python_version<'3.12'
+# lxml 4.9.3 switched to manylinux_2_28, the wheel builder still uses manylinux2014
+lxml>=4.9.1,<4.9.3; (python_version<'3.11' or sys_platform!='win32') and python_version<'3.12'
 pre-commit
 pre-commit-hooks==4.4.0
 psutil>=4.0

From 91e4ce496fd6032c8670d1d3ce350930ab4f3aa4 Mon Sep 17 00:00:00 2001
From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
Date: Fri, 7 Jul 2023 05:05:14 +0200
Subject: [PATCH 126/129] Enable strict optional for more test files (7)
 (#15604)

---
 mypy/test/testcheck.py                      |   5 -
 test-data/unit/check-inference-context.test | 176 ++++++++++----------
 test-data/unit/check-inference.test         | 111 ++++++------
 test-data/unit/check-isinstance.test        |  23 +--
 test-data/unit/check-kwargs.test            |  37 ++--
 test-data/unit/check-literal.test           |  18 +-
 6 files changed, 199 insertions(+), 171 deletions(-)

diff --git a/mypy/test/testcheck.py b/mypy/test/testcheck.py
index f15e5afabf0e8..c91bd915096f7 100644
--- a/mypy/test/testcheck.py
+++ b/mypy/test/testcheck.py
@@ -51,11 +51,6 @@
 
 # TODO: Enable strict optional in test cases by default. Remove files here, once test cases are updated
 no_strict_optional_files = {
-    "check-inference-context.test",
-    "check-inference.test",
-    "check-isinstance.test",
-    "check-kwargs.test",
-    "check-literal.test",
     "check-modules.test",
     "check-namedtuple.test",
     "check-overloading.test",
diff --git a/test-data/unit/check-inference-context.test b/test-data/unit/check-inference-context.test
index 625ab091a6a99..13cfec46eeabe 100644
--- a/test-data/unit/check-inference-context.test
+++ b/test-data/unit/check-inference-context.test
@@ -13,9 +13,9 @@ def f() -> 'A[T]': pass
 class A(Generic[T]): pass
 class B: pass
 
-ab = None # type: A[B]
-ao = None # type: A[object]
-b = None # type: B
+ab: A[B]
+ao: A[object]
+b: B
 
 if int():
     ao = f()
@@ -28,9 +28,9 @@ from typing import TypeVar, Generic
 T = TypeVar('T')
 class A(Generic[T]): pass
 class B: pass
-ab = None # type: A[B]
-ao = None # type: A[object]
-b = None # type: B
+ab: A[B]
+ao: A[object]
+b: B
 
 if int():
     ao = A()
@@ -48,11 +48,11 @@ class A(Generic[T]): pass
 
 class B: pass
 class C: pass
-b = None # type: B
-c = None # type: C
-ab = None # type: A[B]
-ao = None # type: A[object]
-ac = None # type: A[C]
+b: B
+c: C
+ab: A[B]
+ao: A[object]
+ac: A[C]
 
 if int():
     ac = f(b) # E: Argument 1 to "f" has incompatible type "B"; expected "C"
@@ -77,10 +77,10 @@ if int():
 from typing import TypeVar, Generic
 T = TypeVar('T')
 def g() -> None:
-    ao = None # type: A[object]
-    ab = None # type: A[B]
-    o = None # type: object
-    b = None # type: B
+    ao: A[object]
+    ab: A[B]
+    o: object
+    b: B
 
     x = f(o)
     if int():
@@ -111,9 +111,9 @@ class A(Generic[T]): pass
 from typing import TypeVar, Generic
 T = TypeVar('T')
 def g() -> None:
-    ao = None # type: A[object]
-    ab = None # type: A[B]
-    b = None # type: B
+    ao: A[object]
+    ab: A[B]
+    b: B
     x, y = f(b), f(b)
     if int():
         ao = x # E: Incompatible types in assignment (expression has type "A[B]", variable has type "A[object]")
@@ -130,9 +130,9 @@ class B: pass
 from typing import TypeVar, List, Generic
 T = TypeVar('T')
 def h() -> None:
-    ao = None # type: A[object]
-    ab = None # type: A[B]
-    b = None # type: B
+    ao: A[object]
+    ab: A[B]
+    b: B
     x, y = g(f(b))
     if int():
         ao = x # E: Incompatible types in assignment (expression has type "A[B]", variable has type "A[object]")
@@ -162,10 +162,10 @@ def f(a: T) -> 'Tuple[A[T], A[T]]': pass
 class A(Generic[T]): pass
 class B: pass
 
-b = None # type: B
-o = None # type: object
-ab = None # type: A[B]
-ao = None # type: A[object]
+b: B
+o: object
+ab: A[B]
+ao: A[object]
 
 if int():
     ab, ao = f(b) # E: Incompatible types in assignment (expression has type "A[B]", variable has type "A[object]")
@@ -192,10 +192,10 @@ def h(a: S, b: T) -> 'Tuple[A[S], A[S], A[T], A[T]]': pass
 class A(Generic[T]): pass
 class B: pass
 
-b = None # type: B
-o = None # type: object
-ab = None # type: A[B]
-ao = None # type: A[object]
+b: B
+o: object
+ab: A[B]
+ao: A[object]
 
 if int():
     ao, ao, ab = f(b, b)     # E: Incompatible types in assignment (expression has type "A[B]", variable has type "A[object]")
@@ -229,12 +229,12 @@ class A(Generic[T]): pass
 class B: pass
 class C(B): pass
 
-ac = None # type: A[C]
-ab = None # type: A[B]
-ao = None # type: A[object]
-b = None # type: B
-c = None # type: C
-o = None # type: object
+ac: A[C]
+ab: A[B]
+ao: A[object]
+b: B
+c: C
+o: object
 
 if int():
     ab = f(b, o) # E: Argument 2 to "f" has incompatible type "object"; expected "B"
@@ -266,11 +266,11 @@ def f(a: T) -> 'A[T]': pass
 class A(Generic[T]): pass
 class B: pass
 
-aab = None # type: A[A[B]]
-aao = None # type: A[A[object]]
-ao = None # type: A[object]
-b = None # type: B
-o = None # type: object
+aab: A[A[B]]
+aao: A[A[object]]
+ao: A[object]
+b: B
+o: object
 
 if int():
     aab = f(f(o)) # E: Argument 1 to "f" has incompatible type "object"; expected "B"
@@ -279,6 +279,7 @@ if int():
     aab = f(f(b))
     aao = f(f(b))
     ao = f(f(b))
+
 [case testNestedGenericFunctionCall2]
 from typing import TypeVar, Generic
 T = TypeVar('T')
@@ -289,10 +290,10 @@ def g(a: T) -> 'A[T]': pass
 class A(Generic[T]): pass
 class B: pass
 
-ab = None # type: A[B]
-ao = None # type: A[object]
-b = None # type: B
-o = None # type: object
+ab: A[B]
+ao: A[object]
+b: B
+o: object
 
 if int():
     ab = f(g(o)) # E: Argument 1 to "g" has incompatible type "object"; expected "B"
@@ -300,6 +301,7 @@ if int():
 if int():
     ab = f(g(b))
     ao = f(g(b))
+
 [case testNestedGenericFunctionCall3]
 from typing import TypeVar, Generic
 T = TypeVar('T')
@@ -310,10 +312,10 @@ def g(a: T) -> 'A[T]': pass
 
 class A(Generic[T]): pass
 class B: pass
-ab = None # type: A[B]
-ao = None # type: A[object]
-b = None # type: B
-o = None # type: object
+ab: A[B]
+ao: A[object]
+b: B
+o: object
 
 if int():
     ab = f(g(o), g(b)) # E: Argument 1 to "g" has incompatible type "object"; expected "B"
@@ -334,9 +336,9 @@ if int():
 [case testMethodCallWithContextInference]
 from typing import TypeVar, Generic
 T = TypeVar('T')
-o = None # type: object
-b = None # type: B
-c = None # type: C
+o: object
+b: B
+c: C
 def f(a: T) -> 'A[T]': pass
 
 class A(Generic[T]):
@@ -344,9 +346,9 @@ class A(Generic[T]):
 
 class B: pass
 class C(B): pass
-ao = None # type: A[object]
-ab = None # type: A[B]
-ac = None # type: A[C]
+ao: A[object]
+ab: A[B]
+ac: A[C]
 
 ab.g(f(o))        # E: Argument 1 to "f" has incompatible type "object"; expected "B"
 if int():
@@ -365,9 +367,9 @@ ab.g(f(c))
 
 [case testEmptyListExpression]
 from typing import List
-aa = None # type: List[A]
-ao = None # type: List[object]
-a = None # type: A
+aa: List[A]
+ao: List[object]
+a: A
 def f(): a, aa, ao # Prevent redefinition
 
 a = [] # E: Incompatible types in assignment (expression has type "List[<nothing>]", variable has type "A")
@@ -379,15 +381,15 @@ class A: pass
 [builtins fixtures/list.pyi]
 
 [case testSingleItemListExpressions]
-from typing import List
-aa = None # type: List[A]
-ab = None # type: List[B]
-ao = None # type: List[object]
-a = None # type: A
-b = None # type: B
+from typing import List, Optional
+aa: List[Optional[A]]
+ab: List[B]
+ao: List[object]
+a: A
+b: B
 def f(): aa, ab, ao # Prevent redefinition
 
-aa = [b] # E: List item 0 has incompatible type "B"; expected "A"
+aa = [b] # E: List item 0 has incompatible type "B"; expected "Optional[A]"
 ab = [a] # E: List item 0 has incompatible type "A"; expected "B"
 
 aa = [a]
@@ -402,11 +404,11 @@ class B: pass
 
 [case testMultiItemListExpressions]
 from typing import List
-aa = None # type: List[A]
-ab = None # type: List[B]
-ao = None # type: List[object]
-a = None # type: A
-b = None # type: B
+aa: List[A]
+ab: List[B]
+ao: List[object]
+a: A
+b: B
 def f(): ab, aa, ao # Prevent redefinition
 
 ab = [b, a] # E: List item 1 has incompatible type "A"; expected "B"
@@ -433,6 +435,7 @@ class B: pass
 [out]
 
 [case testNestedListExpressions]
+# flags: --no-strict-optional
 from typing import List
 aao = None # type: List[List[object]]
 aab = None # type: List[List[B]]
@@ -596,17 +599,17 @@ y = C() # type: Any
 
 [case testInferLambdaArgumentTypeUsingContext]
 from typing import Callable
-f = None # type: Callable[[B], A]
+f: Callable[[B], A]
 if int():
     f = lambda x: x.o
     f = lambda x: x.x # E: "B" has no attribute "x"
 class A: pass
 class B:
-  o = None # type: A
+  o: A
 
 [case testInferLambdaReturnTypeUsingContext]
 from typing import List, Callable
-f = None # type: Callable[[], List[A]]
+f: Callable[[], List[A]]
 if int():
     f = lambda: []
     f = lambda: [B()]  # E: List item 0 has incompatible type "B"; expected "A"
@@ -680,6 +683,7 @@ def foo(arg: Callable[..., T]) -> None: pass
 foo(lambda: 1)
 
 [case testLambdaNoneInContext]
+# flags: --no-strict-optional
 from typing import Callable
 def f(x: Callable[[], None]) -> None: pass
 def g(x: Callable[[], int]) -> None: pass
@@ -687,13 +691,13 @@ f(lambda: None)
 g(lambda: None)
 
 [case testIsinstanceInInferredLambda]
-from typing import TypeVar, Callable
+from typing import TypeVar, Callable, Optional
 T = TypeVar('T')
 S = TypeVar('S')
 class A: pass
 class B(A): pass
 class C(A): pass
-def f(func: Callable[[T], S], *z: T, r: S = None) -> S: pass
+def f(func: Callable[[T], S], *z: T, r: Optional[S] = None) -> S: pass
 f(lambda x: 0 if isinstance(x, B) else 1) # E: Cannot infer type argument 1 of "f"
 f(lambda x: 0 if isinstance(x, B) else 1, A())() # E: "int" not callable
 f(lambda x: x if isinstance(x, B) else B(), A(), r=B())() # E: "B" not callable
@@ -739,7 +743,9 @@ from typing import List
 class A: pass
 class B: pass
 class C(B): pass
-a, b, c = None, None, None # type: (List[A], List[B], List[C])
+a: List[A]
+b: List[B]
+c: List[C]
 if int():
     a = a or []
 if int():
@@ -762,7 +768,7 @@ from typing import List, TypeVar
 t = TypeVar('t')
 s = TypeVar('s')
 # Some type variables can be inferred using context, but not all of them.
-a = None # type: List[A]
+a: List[A]
 def f(a: s, b: t) -> List[s]: pass
 class A: pass
 class B: pass
@@ -780,7 +786,7 @@ def f(a: s, b: t) -> List[s]: pass
 class A: pass
 class B: pass
 # Like testSomeTypeVarsInferredFromContext, but tvars in different order.
-a = None # type: List[A]
+a: List[A]
 if int():
     a = f(A(), B())
 if int():
@@ -800,8 +806,8 @@ map(
 
 [case testChainedAssignmentInferenceContexts]
 from typing import List
-i = None # type: List[int]
-s = None # type: List[str]
+i: List[int]
+s: List[str]
 if int():
     i = i = []
 if int():
@@ -821,10 +827,10 @@ a.x = [''] # E: List item 0 has incompatible type "str"; expected "int"
 
 [case testListMultiplyInContext]
 from typing import List
-a = None  # type: List[int]
+a: List[int]
 if int():
-    a = [None] * 3
-    a = [''] * 3 # E: List item 0 has incompatible type "str"; expected "int"
+    a = [None] * 3  # E: List item 0 has incompatible type "None"; expected "int"
+    a = [''] * 3  # E: List item 0 has incompatible type "str"; expected "int"
 [builtins fixtures/list.pyi]
 
 [case testUnionTypeContext]
@@ -847,7 +853,7 @@ g(f(a))
 
 [case testStar2Context]
 from typing import Any, Dict, Tuple, Iterable
-def f1(iterable: Iterable[Tuple[str, Any]] = None) -> None:
+def f1(iterable: Iterable[Tuple[str, Any]] = ()) -> None:
     f2(**dict(iterable))
 def f2(iterable: Iterable[Tuple[str, Any]], **kw: Any) -> None:
     pass
@@ -913,7 +919,7 @@ T = TypeVar('T')
 def f(x: Union[T, List[int]]) -> Union[T, List[int]]: pass
 reveal_type(f(1)) # N: Revealed type is "Union[builtins.int, builtins.list[builtins.int]]"
 reveal_type(f([])) # N: Revealed type is "builtins.list[builtins.int]"
-reveal_type(f(None)) # N: Revealed type is "builtins.list[builtins.int]"
+reveal_type(f(None)) # N: Revealed type is "Union[None, builtins.list[builtins.int]]"
 [builtins fixtures/list.pyi]
 
 [case testUnionWithGenericTypeItemContextAndStrictOptional]
@@ -941,7 +947,7 @@ c = C[List[int]]()
 reveal_type(c.f('')) # N: Revealed type is "Union[builtins.list[builtins.int], builtins.str]"
 reveal_type(c.f([1])) # N: Revealed type is "builtins.list[builtins.int]"
 reveal_type(c.f([])) # N: Revealed type is "builtins.list[builtins.int]"
-reveal_type(c.f(None)) # N: Revealed type is "builtins.list[builtins.int]"
+reveal_type(c.f(None)) # N: Revealed type is "Union[builtins.list[builtins.int], None]"
 [builtins fixtures/list.pyi]
 
 [case testGenericMethodCalledInGenericContext]
diff --git a/test-data/unit/check-inference.test b/test-data/unit/check-inference.test
index 166e173e73016..ee13cb3830fcd 100644
--- a/test-data/unit/check-inference.test
+++ b/test-data/unit/check-inference.test
@@ -54,7 +54,7 @@ class B: pass
 
 [case testInferringLvarTypeFromGvar]
 
-g = None # type: B
+g: B
 
 def f() -> None:
     a = g
@@ -78,7 +78,7 @@ def g(): pass
 
 [case testInferringExplicitDynamicTypeForLvar]
 from typing import Any
-g = None # type: Any
+g: Any
 
 def f(a: Any) -> None:
     b = g
@@ -95,8 +95,8 @@ def f(a: Any) -> None:
 
 def f() -> None:
     a = A(), B()
-    aa = None # type: A
-    bb = None # type: B
+    aa: A
+    bb: B
     if int():
         bb = a[0] # E: Incompatible types in assignment (expression has type "A", variable has type "B")
         aa = a[1] # E: Incompatible types in assignment (expression has type "B", variable has type "A")
@@ -122,8 +122,8 @@ class A: pass
 from typing import TypeVar, Generic
 T = TypeVar('T')
 class A(Generic[T]): pass
-a_i = None # type: A[int]
-a_s = None # type: A[str]
+a_i: A[int]
+a_s: A[str]
 
 def f() -> None:
     a_int = A() # type: A[int]
@@ -182,7 +182,7 @@ class B: pass
 [case testInferringLvarTypesInTupleAssignment]
 from typing import Tuple
 def f() -> None:
-    t = None # type: Tuple[A, B]
+    t: Tuple[A, B]
     a, b = t
     if int():
         a = b   # E: Incompatible types in assignment (expression has type "B", variable has type "A")
@@ -200,7 +200,7 @@ class B: pass
 [case testInferringLvarTypesInNestedTupleAssignment1]
 from typing import Tuple
 def f() -> None:
-    t = None # type: Tuple[A, B]
+    t: Tuple[A, B]
     a1, (a, b) = A(), t
     if int():
         a = b   # E: Incompatible types in assignment (expression has type "B", variable has type "A")
@@ -386,7 +386,7 @@ reveal_type(C)  # N: Revealed type is "__main__.Foo"
 
 [case testInferringLvarTypesInMultiDefWithInvalidTuple]
 from typing import Tuple
-t = None # type: Tuple[object, object, object]
+t: Tuple[object, object, object]
 
 def f() -> None:
     a, b = t         # Fail
@@ -543,9 +543,9 @@ if int():
 [case testInferSimpleGenericFunction]
 from typing import Tuple, TypeVar
 T = TypeVar('T')
-a = None # type: A
-b = None # type: B
-c = None # type: Tuple[A, object]
+a: A
+b: B
+c: Tuple[A, object]
 
 def id(a: T) -> T: pass
 
@@ -569,8 +569,8 @@ from typing import TypeVar
 T = TypeVar('T')
 def f() -> None:
     a = id
-    b = None # type: int
-    c = None # type: str
+    b: int
+    c: str
     if int():
         b = a(c) # E: Incompatible types in assignment (expression has type "str", variable has type "int")
         b = a(b)
@@ -584,7 +584,7 @@ def id(x: T) -> T:
 from typing import TypeVar
 T = TypeVar('T')
 class A: pass
-a = None # type: A
+a: A
 
 def ff() -> None:
     x = f() # E: Need type annotation for "x"
@@ -605,8 +605,8 @@ class A: pass
 class B(A): pass
 
 T = TypeVar('T')
-a = None # type: A
-b = None # type: B
+a: A
+b: B
 
 def f(a: T, b: T) -> T: pass
 
@@ -629,10 +629,11 @@ def f(a: T, b: S) -> Tuple[T, S]: pass
 class A: pass
 class B: pass
 
-a, b = None, None # type: (A, B)
-taa = None # type: Tuple[A, A]
-tab = None # type: Tuple[A, B]
-tba = None # type: Tuple[B, A]
+a: A
+b: B
+taa: Tuple[A, A]
+tab: Tuple[A, B]
+tba: Tuple[B, A]
 
 if int():
     taa = f(a, b) # E: Argument 2 to "f" has incompatible type "B"; expected "A"
@@ -651,9 +652,9 @@ if int():
 [case testConstraintSolvingWithSimpleGenerics]
 from typing import TypeVar, Generic
 T = TypeVar('T')
-ao = None # type: A[object]
-ab = None # type: A[B]
-ac = None # type: A[C]
+ao: A[object]
+ab: A[B]
+ac: A[C]
 
 def f(a: 'A[T]') -> 'A[T]': pass
 
@@ -683,8 +684,8 @@ if int():
 [case testConstraintSolvingFailureWithSimpleGenerics]
 from typing import TypeVar, Generic
 T = TypeVar('T')
-ao = None # type: A[object]
-ab = None # type: A[B]
+ao: A[object]
+ab: A[B]
 
 def f(a: 'A[T]', b: 'A[T]') -> None: pass
 
@@ -696,7 +697,9 @@ f(ao, ab) # E: Cannot infer type argument 1 of "f"
 f(ab, ao) # E: Cannot infer type argument 1 of "f"
 f(ao, ao)
 f(ab, ab)
+
 [case testTypeInferenceWithCalleeDefaultArgs]
+# flags: --no-strict-optional
 from typing import TypeVar
 T = TypeVar('T')
 a = None # type: A
@@ -809,7 +812,9 @@ class C(A, I, J): pass
 def f(a: T, b: T) -> T: pass
 
 T = TypeVar('T')
-a, i, j = None, None, None # type: (A, I, J)
+a: A
+i: I
+j: J
 
 a = f(B(), C())
 
@@ -846,7 +851,7 @@ from typing import Callable, Type, TypeVar
 T = TypeVar('T')
 def f(x: Callable[..., T]) -> T: return x()
 class A: pass
-x = None  # type: Type[A]
+x: Type[A]
 y = f(x)
 reveal_type(y)  # N: Revealed type is "__main__.A"
 
@@ -1031,7 +1036,8 @@ class A: pass
 class B: pass
 def d_ab() -> Dict[A, B]: return {}
 def d_aa() -> Dict[A, A]: return {}
-a, b = None, None # type: (A, B)
+a: A
+b: B
 d = {a:b}
 if int():
     d = d_ab()
@@ -1041,7 +1047,8 @@ if int():
 
 [case testSetLiteral]
 from typing import Any, Set
-a, x = None, None # type: (int, Any)
+a: int
+x: Any
 def s_i() -> Set[int]: return set()
 def s_s() -> Set[str]: return set()
 s = {a}
@@ -1113,7 +1120,8 @@ list_2 = [f, h]
 
 
 [case testInferenceOfFor1]
-a, b = None, None # type: (A, B)
+a: A
+b: B
 
 class A: pass
 class B: pass
@@ -1132,7 +1140,9 @@ class A: pass
 class B: pass
 class C: pass
 
-a, b, c = None, None, None # type: (A, B, C)
+a: A
+b: B
+c: C
 for x, (y, z) in [(A(), (B(), C()))]:
     b = x # E: Incompatible types in assignment (expression has type "A", variable has type "B")
     c = y # E: Incompatible types in assignment (expression has type "B", variable has type "C")
@@ -1152,7 +1162,8 @@ for xxx, yyy in [(None, None)]:
 class A: pass
 class B: pass
 
-a, b = None, None # type: (A, B)
+a: A
+b: B
 
 for x, y in [[A()]]:
     b = x # E: Incompatible types in assignment (expression has type "A", variable has type "B")
@@ -1234,7 +1245,7 @@ class B: pass
 
 
 [case testMultipleAssignmentWithPartialDefinition]
-a = None # type: A
+a: A
 if int():
     x, a = a, a
     if int():
@@ -1246,7 +1257,7 @@ if int():
 class A: pass
 
 [case testMultipleAssignmentWithPartialDefinition2]
-a = None # type: A
+a: A
 if int():
     a, x = [a, a]
     if int():
@@ -1260,7 +1271,7 @@ class A: pass
 
 [case testMultipleAssignmentWithPartialDefinition3]
 from typing import Any, cast
-a = None # type: A
+a: A
 if int():
     x, a = cast(Any, a)
     if int():
@@ -1275,7 +1286,7 @@ class A: pass
 class A: pass
 class B: pass
 
-if A:
+if int():
     a = A()
     if int():
         a = A()
@@ -1380,6 +1391,7 @@ main:4: error: Cannot infer type argument 1 of "f"
 main:4: error: Argument 2 to "f" has incompatible type "int"; expected "str"
 
 [case testInferLambdaNone]
+# flags: --no-strict-optional
 from typing import Callable
 def f(x: Callable[[], None]) -> None: pass
 def g(x: Callable[[], int]) -> None: pass
@@ -1442,8 +1454,8 @@ def g(cond: bool) -> Any:
 
 [case testOrOperationWithGenericOperands]
 from typing import List
-a = None # type: List[A]
-o = None # type: List[object]
+a: List[A]
+o: List[object]
 a2 = a or []
 if int():
     a = a2
@@ -1464,7 +1476,7 @@ x.y  # E: "object" has no attribute "y"
 
 [case testAccessDataAttributeBeforeItsTypeIsAvailable]
 
-a = None # type: A
+a: A
 a.x.y  # E: Cannot determine type of "x"
 class A:
    def __init__(self) -> None:
@@ -1481,7 +1493,7 @@ from typing import List, _promote
 class A: pass
 @_promote(A)
 class B: pass
-a = None  # type: List[A]
+a: List[A]
 x1 = [A(), B()]
 x2 = [B(), A()]
 x3 = [B(), B()]
@@ -1504,7 +1516,7 @@ class A: pass
 class B: pass
 @_promote(B)
 class C: pass
-a = None  # type: List[A]
+a: List[A]
 x1 = [A(), C()]
 x2 = [C(), A()]
 x3 = [B(), C()]
@@ -1915,6 +1927,7 @@ reveal_type(dd)  # N: Revealed type is "builtins.dict[builtins.str, builtins.int
 [builtins fixtures/dict.pyi]
 
 [case testInferFromEmptyDictWhenUsingInSpecialCase]
+# flags: --no-strict-optional
 d = None
 if 'x' in d:  # E: "None" has no attribute "__iter__" (not iterable)
     pass
@@ -1937,6 +1950,7 @@ reveal_type(a)  # N: Revealed type is "builtins.list[builtins.int]"
 [builtins fixtures/list.pyi]
 
 [case testInferSetTypeFromInplaceOr]
+# flags: --no-strict-optional
 a = set()
 a |= {'x'}
 reveal_type(a)  # N: Revealed type is "builtins.set[builtins.str]"
@@ -1953,7 +1967,8 @@ def f() -> None:
         x = None
     else:
         x = 1
-    x() # E: "int" not callable
+    x() # E: "int" not callable \
+        # E: "None" not callable
 [out]
 
 [case testLocalVariablePartiallyTwiceInitializedToNone]
@@ -1964,7 +1979,8 @@ def f() -> None:
         x = None
     else:
         x = 1
-    x() # E: "int" not callable
+    x() # E: "int" not callable \
+        # E: "None" not callable
 [out]
 
 [case testLvarInitializedToNoneWithoutType]
@@ -1978,7 +1994,8 @@ def f() -> None:
 x = None
 if object():
     x = 1
-x() # E: "int" not callable
+x() # E: "int" not callable \
+    # E: "None" not callable
 
 [case testPartiallyInitializedToNoneAndThenToPartialList]
 x = None
@@ -2339,8 +2356,8 @@ reveal_type(A.g)  # N: Revealed type is "def (x: builtins.str)"
 
 [case testUnificationRedundantUnion]
 from typing import Union
-a = None  # type: Union[int, str]
-b = None  # type: Union[str, tuple]
+a: Union[int, str]
+b: Union[str, tuple]
 def f(): pass
 def g(x: Union[int, str]): pass
 c = a if f() else b
diff --git a/test-data/unit/check-isinstance.test b/test-data/unit/check-isinstance.test
index 2d010b8ba38d8..3403e726d8b57 100644
--- a/test-data/unit/check-isinstance.test
+++ b/test-data/unit/check-isinstance.test
@@ -10,7 +10,7 @@ y = x
 [case testJoinAny]
 from typing import List, Any
 
-x = None # type: List[Any]
+x: List[Any]
 
 def foo() -> List[int]: pass
 def bar() -> List[str]: pass
@@ -51,9 +51,9 @@ def f(x: Union[int, str, List]) -> None:
 
 [case testClassAttributeInitialization]
 class A:
-    x = None # type: int
+    x: int
     def __init__(self) -> None:
-        self.y = None # type: int
+        self.y: int
         z = self.x
         w = self.y
 
@@ -71,7 +71,7 @@ def foo(x: Union[str, int]):
     y + [1]  # E: List item 0 has incompatible type "int"; expected "str"
     z = 1  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
 
-x = None # type: int
+x: int
 y = [x]
 [builtins fixtures/isinstancelist.pyi]
 
@@ -124,7 +124,7 @@ x = 'a'
 
 [case testUnionMultiAssignment]
 from typing import Union
-x = None # type: Union[int, str]
+x: Union[int, str]
 if int():
     x = 1
     x = 'a'
@@ -488,7 +488,7 @@ x.y        # OK: x is known to be a B
 
 [case testIsInstanceBasic]
 from typing import Union
-x = None # type: Union[int, str]
+x: Union[int, str]
 if isinstance(x, str):
     x = x + 1   # E: Unsupported operand types for + ("str" and "int")
     x = x + 'a'
@@ -499,7 +499,7 @@ else:
 
 [case testIsInstanceIndexing]
 from typing import Union
-x = None # type: Union[int, str]
+x: Union[int, str]
 j = [x]
 if isinstance(j[0], str):
     j[0] = j[0] + 'a'
@@ -671,7 +671,7 @@ foo()
 from typing import Union
 
 def foo() -> None:
-    x = None # type: Union[int, str]
+    x: Union[int, str]
     if isinstance(x, int):
         for z in [1,2]:
             break
@@ -686,7 +686,7 @@ foo()
 [case testIsInstanceThreeUnion]
 from typing import Union, List
 
-x = None # type: Union[int, str, List[int]]
+x: Union[int, str, List[int]]
 
 while bool():
     if isinstance(x, int):
@@ -706,7 +706,7 @@ x + [1]               # E: Unsupported operand types for + ("int" and "List[int]
 
 [case testIsInstanceThreeUnion2]
 from typing import Union, List
-x = None # type: Union[int, str, List[int]]
+x: Union[int, str, List[int]]
 while bool():
     if isinstance(x, int):
         x + 1
@@ -725,7 +725,7 @@ x + [1]               # E: Unsupported operand types for + ("int" and "List[int]
 from typing import Union, List
 
 while bool():
-    x = None # type: Union[int, str, List[int]]
+    x: Union[int, str, List[int]]
     def f(): x  # Prevent redefinition
     x = 1
     if isinstance(x, int):
@@ -1787,6 +1787,7 @@ issubclass(x, (int, Iterable[int]))  # E: Parameterized generics cannot be used
 [typing fixtures/typing-full.pyi]
 
 [case testIssubclassWithMetaclasses]
+# flags: --no-strict-optional
 class FooMetaclass(type): ...
 class Foo(metaclass=FooMetaclass): ...
 class Bar: ...
diff --git a/test-data/unit/check-kwargs.test b/test-data/unit/check-kwargs.test
index 81fdc444acedf..b3ee47aa6fdfd 100644
--- a/test-data/unit/check-kwargs.test
+++ b/test-data/unit/check-kwargs.test
@@ -54,6 +54,7 @@ f(b=[], a=A())
 [builtins fixtures/list.pyi]
 
 [case testGivingArgumentAsPositionalAndKeywordArg]
+# flags: --no-strict-optional
 import typing
 class A: pass
 class B: pass
@@ -61,11 +62,13 @@ def f(a: 'A', b: 'B' = None) -> None: pass
 f(A(), a=A()) # E: "f" gets multiple values for keyword argument "a"
 
 [case testGivingArgumentAsPositionalAndKeywordArg2]
+# flags: --no-strict-optional
 import typing
 class A: pass
 class B: pass
 def f(a: 'A' = None, b: 'B' = None) -> None: pass
 f(A(), a=A()) # E: "f" gets multiple values for keyword argument "a"
+
 [case testPositionalAndKeywordForSameArg]
 # This used to crash in check_argument_count(). See #1095.
 def f(a: int): pass
@@ -134,7 +137,7 @@ f(otter=A()) # E: Missing positional argument "other" in call to "f"
 
 [case testKeywordArgumentsWithDynamicallyTypedCallable]
 from typing import Any
-f = None # type: Any
+f: Any
 f(x=f(), z=None()) # E: "None" not callable
 f(f, zz=None()) # E: "None" not callable
 f(x=None)
@@ -143,10 +146,12 @@ f(x=None)
 from typing import Callable
 class A: pass
 class B: pass
-f = None # type: Callable[[A, B], None]
+f: Callable[[A, B], None]
 f(a=A(), b=B())  # E: Unexpected keyword argument "a"  # E: Unexpected keyword argument "b"
 f(A(), b=B())  # E: Unexpected keyword argument "b"
+
 [case testKeywordOnlyArguments]
+# flags: --no-strict-optional
 import typing
 class A: pass
 class B: pass
@@ -172,7 +177,9 @@ i(A(), b=B())
 i(A(), aa=A()) # E: Missing named argument "b" for "i"
 i(A(), b=B(), aa=A())
 i(A(), aa=A(), b=B())
+
 [case testKeywordOnlyArgumentsFastparse]
+# flags: --no-strict-optional
 import typing
 
 class A: pass
@@ -290,10 +297,10 @@ from typing import Dict
 class A: pass
 class B: pass
 def f( **kwargs: 'A') -> None: pass
-d = None # type: Dict[str, A]
+d: Dict[str, A]
 f(**d)
 f(x=A(), **d)
-d2 = None # type: Dict[str, B]
+d2: Dict[str, B]
 f(**d2)         # E: Argument 1 to "f" has incompatible type "**Dict[str, B]"; expected "A"
 f(x=A(), **d2)  # E: Argument 2 to "f" has incompatible type "**Dict[str, B]"; expected "A"
 f(**{'x': B()}) # E: Argument 1 to "f" has incompatible type "**Dict[str, B]"; expected "A"
@@ -324,9 +331,9 @@ reveal_type(formatter.__call__)  # N: Revealed type is "def (message: builtins.s
 [case testPassingMappingForKeywordVarArg]
 from typing import Mapping
 def f(**kwargs: 'A') -> None: pass
-b = None # type: Mapping
-d = None # type: Mapping[A, A]
-m = None # type: Mapping[str, A]
+b: Mapping
+d: Mapping[A, A]
+m: Mapping[str, A]
 f(**d)         # E: Keywords must be strings
 f(**m)
 f(**b)
@@ -337,7 +344,7 @@ class A: pass
 from typing import Mapping
 class MappingSubclass(Mapping[str, str]): pass
 def f(**kwargs: 'A') -> None: pass
-d = None # type: MappingSubclass
+d: MappingSubclass
 f(**d)
 class A: pass
 [builtins fixtures/dict.pyi]
@@ -357,9 +364,9 @@ f(**kwargs)    # E: Argument after ** must be a mapping, not "Optional[Any]"
 [case testPassingKeywordVarArgsToNonVarArgsFunction]
 from typing import Any, Dict
 def f(a: 'A', b: 'B') -> None: pass
-d = None # type: Dict[str, Any]
+d: Dict[str, Any]
 f(**d)
-d2 = None # type: Dict[str, A]
+d2: Dict[str, A]
 f(**d2) # E: Argument 1 to "f" has incompatible type "**Dict[str, A]"; expected "B"
 class A: pass
 class B: pass
@@ -368,8 +375,8 @@ class B: pass
 [case testBothKindsOfVarArgs]
 from typing import Any, List, Dict
 def f(a: 'A', b: 'A') -> None: pass
-l = None # type: List[Any]
-d = None # type: Dict[Any, Any]
+l: List[Any]
+d: Dict[Any, Any]
 f(*l, **d)
 class A: pass
 [builtins fixtures/dict.pyi]
@@ -380,8 +387,8 @@ def f1(a: 'A', b: 'A') -> None: pass
 def f2(a: 'A') -> None: pass
 def f3(a: 'A', **kwargs: 'A') -> None: pass
 def f4(**kwargs: 'A') -> None: pass
-d = None # type: Dict[Any, Any]
-d2 = None # type: Dict[Any, Any]
+d: Dict[Any, Any]
+d2: Dict[Any, Any]
 f1(**d, **d2)
 f2(**d, **d2)
 f3(**d, **d2)
@@ -392,7 +399,7 @@ class A: pass
 [case testPassingKeywordVarArgsToVarArgsOnlyFunction]
 from typing import Any, Dict
 def f(*args: 'A') -> None: pass
-d = None # type: Dict[Any, Any]
+d: Dict[Any, Any]
 f(**d)
 class A: pass
 [builtins fixtures/dict.pyi]
diff --git a/test-data/unit/check-literal.test b/test-data/unit/check-literal.test
index 1a529051259f3..104dd4d144e09 100644
--- a/test-data/unit/check-literal.test
+++ b/test-data/unit/check-literal.test
@@ -753,16 +753,16 @@ Foo = Literal[5]
 [case testLiteralBiasTowardsAssumingForwardReferencesForTypeComments]
 from typing_extensions import Literal
 
-a = None  # type: Foo
+a: Foo
 reveal_type(a)      # N: Revealed type is "__main__.Foo"
 
-b = None  # type: "Foo"
+b: "Foo"
 reveal_type(b)      # N: Revealed type is "__main__.Foo"
 
-c = None  # type: Literal["Foo"]
+c: Literal["Foo"]
 reveal_type(c)      # N: Revealed type is "Literal['Foo']"
 
-d = None  # type: Literal[Foo]   # E: Parameter 1 of Literal[...] is invalid
+d: Literal[Foo]     # E: Parameter 1 of Literal[...] is invalid
 
 class Foo: pass
 [builtins fixtures/tuple.pyi]
@@ -1760,7 +1760,7 @@ reveal_type(func1(identity(b)))  # N: Revealed type is "builtins.int"
 --
 
 [case testLiteralMeets]
-from typing import TypeVar, List, Callable, Union
+from typing import TypeVar, List, Callable, Union, Optional
 from typing_extensions import Literal
 
 a: Callable[[Literal[1]], int]
@@ -1794,12 +1794,14 @@ def f2(x: Literal[1], y: Literal[2]) -> None: pass
 def f3(x: Literal[1], y: int) -> None: pass
 def f4(x: Literal[1], y: object) -> None: pass
 def f5(x: Literal[1], y: Union[Literal[1], Literal[2]]) -> None: pass
+def f6(x: Optional[Literal[1]], y: Optional[Literal[2]]) -> None: pass
 
 reveal_type(unify(f1))  # N: Revealed type is "Literal[1]"
-reveal_type(unify(f2))  # N: Revealed type is "None"
+reveal_type(unify(f2))  # N: Revealed type is "<nothing>"
 reveal_type(unify(f3))  # N: Revealed type is "Literal[1]"
 reveal_type(unify(f4))  # N: Revealed type is "Literal[1]"
 reveal_type(unify(f5))  # N: Revealed type is "Literal[1]"
+reveal_type(unify(f6))  # N: Revealed type is "None"
 [builtins fixtures/list.pyi]
 [out]
 
@@ -2013,7 +2015,7 @@ optional_keys: Literal["d", "e"]
 bad_keys: Literal["a", "bad"]
 
 reveal_type(test[good_keys])                      # N: Revealed type is "Union[__main__.A, __main__.B]"
-reveal_type(test.get(good_keys))                  # N: Revealed type is "Union[__main__.A, __main__.B]"
+reveal_type(test.get(good_keys))                  # N: Revealed type is "Union[__main__.A, __main__.B, None]"
 reveal_type(test.get(good_keys, 3))               # N: Revealed type is "Union[__main__.A, Literal[3]?, __main__.B]"
 reveal_type(test.pop(optional_keys))              # N: Revealed type is "Union[__main__.D, __main__.E]"
 reveal_type(test.pop(optional_keys, 3))           # N: Revealed type is "Union[__main__.D, __main__.E, Literal[3]?]"
@@ -2066,7 +2068,7 @@ x[bad_keys]         # E: TypedDict "D1" has no key "d" \
                     # E: TypedDict "D2" has no key "a"
 
 reveal_type(x[good_keys])           # N: Revealed type is "Union[__main__.B, __main__.C]"
-reveal_type(x.get(good_keys))       # N: Revealed type is "Union[__main__.B, __main__.C]"
+reveal_type(x.get(good_keys))       # N: Revealed type is "Union[__main__.B, __main__.C, None]"
 reveal_type(x.get(good_keys, 3))    # N: Revealed type is "Union[__main__.B, Literal[3]?, __main__.C]"
 reveal_type(x.get(bad_keys))        # N: Revealed type is "builtins.object"
 reveal_type(x.get(bad_keys, 3))     # N: Revealed type is "builtins.object"

From ef0b763fb25790892e208cd2691d272494ea7720 Mon Sep 17 00:00:00 2001
From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
Date: Fri, 7 Jul 2023 14:46:25 +0200
Subject: [PATCH 127/129] Enable strict optional for more test files (8)
 (#15606)

Followup to https://github.com/python/mypy/pull/15586
---
 mypy/test/testcheck.py                 |   5 -
 test-data/unit/check-namedtuple.test   |  36 ++---
 test-data/unit/check-overloading.test  |  35 +++--
 test-data/unit/check-plugin-attrs.test |   3 +
 test-data/unit/check-statements.test   | 102 +++++++-------
 test-data/unit/check-tuples.test       | 184 ++++++++++++++-----------
 6 files changed, 202 insertions(+), 163 deletions(-)

diff --git a/mypy/test/testcheck.py b/mypy/test/testcheck.py
index c91bd915096f7..a77da090f7405 100644
--- a/mypy/test/testcheck.py
+++ b/mypy/test/testcheck.py
@@ -52,11 +52,6 @@
 # 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-namedtuple.test",
-    "check-overloading.test",
-    "check-plugin-attrs.test",
-    "check-statements.test",
-    "check-tuples.test",
     "check-unions.test",
     "check-varargs.test",
 }
diff --git a/test-data/unit/check-namedtuple.test b/test-data/unit/check-namedtuple.test
index 5eed70246e8c9..83cc8c099deba 100644
--- a/test-data/unit/check-namedtuple.test
+++ b/test-data/unit/check-namedtuple.test
@@ -2,7 +2,7 @@
 from collections import namedtuple
 
 X = namedtuple('X', 'x y')
-x = None  # type: X
+x: X
 a, b = x
 b = x[0]
 a = x[1]
@@ -14,7 +14,7 @@ x[2] # E: Tuple index out of range
 from collections import namedtuple
 
 X = namedtuple('X', ('x', 'y'))
-x = None  # type: X
+x: X
 a, b = x
 b = x[0]
 a = x[1]
@@ -32,7 +32,7 @@ X = namedtuple('X', 'x, _y, _z')  # E: "namedtuple()" field names cannot start w
 from collections import namedtuple
 
 X = namedtuple('X', 'x y')
-x = None  # type: X
+x: X
 x.x
 x.y
 x.z # E: "X" has no attribute "z"
@@ -63,13 +63,13 @@ class A(NamedTuple):
 from collections import namedtuple
 
 X = namedtuple('X', 'x y')
-x = None  # type: X
+x: X
 x.x = 5 # E: Property "x" defined in "X" is read-only
 x.y = 5 # E: Property "y" defined in "X" is read-only
 x.z = 5 # E: "X" has no attribute "z"
 
 class A(X): pass
-a = None  # type: A
+a: A
 a.x = 5 # E: Property "x" defined in "X" is read-only
 a.y = 5 # E: Property "y" defined in "X" is read-only
 -- a.z = 5 # not supported yet
@@ -292,7 +292,7 @@ A = NamedTuple('A', [('a', int), ('b', str)])
 class B(A): pass
 a = A(1, '')
 b = B(1, '')
-t = None  # type: Tuple[int, str]
+t: Tuple[int, str]
 if int():
     b = a  # E: Incompatible types in assignment (expression has type "A", variable has type "B")
 if int():
@@ -357,7 +357,7 @@ C(2).b
 from collections import namedtuple
 
 X = namedtuple('X', ['x', 'y'])
-x = None  # type: X
+x: X
 reveal_type(x._asdict())  # N: Revealed type is "builtins.dict[builtins.str, Any]"
 
 [builtins fixtures/dict.pyi]
@@ -366,7 +366,7 @@ reveal_type(x._asdict())  # N: Revealed type is "builtins.dict[builtins.str, Any
 from collections import namedtuple
 
 X = namedtuple('X', ['x', 'y'])
-x = None  # type: X
+x: X
 reveal_type(x._replace())  # N: Revealed type is "Tuple[Any, Any, fallback=__main__.X]"
 x._replace(y=5)
 x._replace(x=3)
@@ -391,7 +391,7 @@ X._replace(x=1, y=2)  # E: Missing positional argument "_self" in call to "_repl
 from typing import NamedTuple
 
 X = NamedTuple('X', [('x', int), ('y', str)])
-x = None  # type: X
+x: X
 reveal_type(x._replace())  # N: Revealed type is "Tuple[builtins.int, builtins.str, fallback=__main__.X]"
 x._replace(x=5)
 x._replace(y=5)  # E: Argument "y" to "_replace" of "X" has incompatible type "int"; expected "str"
@@ -405,7 +405,7 @@ reveal_type(X._make([5, 'a']))  # N: Revealed type is "Tuple[builtins.int, built
 X._make('a b')  # E: Argument 1 to "_make" of "X" has incompatible type "str"; expected "Iterable[Any]"
 
 -- # FIX: not a proper class method
--- x = None  # type: X
+-- x: X
 -- reveal_type(x._make([5, 'a']))  # N: Revealed type is "Tuple[builtins.int, builtins.str, fallback=__main__.X]"
 -- x._make('a b')  # E: Argument 1 to "_make" of "X" has incompatible type "str"; expected Iterable[Any]
 
@@ -423,7 +423,7 @@ from typing import NamedTuple
 
 X = NamedTuple('X', [('x', int), ('y', str)])
 reveal_type(X._source)  # N: Revealed type is "builtins.str"
-x = None  # type: X
+x: X
 reveal_type(x._source)  # N: Revealed type is "builtins.str"
 [builtins fixtures/tuple.pyi]
 
@@ -459,7 +459,7 @@ from typing import NamedTuple
 
 X = NamedTuple('X', [('x', int), ('y', str)])
 reveal_type(X._field_types)  # N: Revealed type is "builtins.dict[builtins.str, Any]"
-x = None  # type: X
+x: X
 reveal_type(x._field_types)  # N: Revealed type is "builtins.dict[builtins.str, Any]"
 
 [builtins fixtures/dict.pyi]
@@ -472,7 +472,7 @@ def f(x: A) -> None: pass
 
 class B(NamedTuple('B', []), A): pass
 f(B())
-x = None  # type: A
+x: A
 if int():
     x = B()
 
@@ -482,7 +482,7 @@ def g(x: C) -> None: pass
 class D(NamedTuple('D', []), A): pass
 
 g(D())  # E: Argument 1 to "g" has incompatible type "D"; expected "C"
-y = None  # type: C
+y: C
 if int():
     y = D()  # E: Incompatible types in assignment (expression has type "D", variable has type "C")
 [builtins fixtures/tuple.pyi]
@@ -499,9 +499,9 @@ class A(NamedTuple('A', [('x', str)])):
 class B(A):
     pass
 
-a = None  # type: A
+a: A
 a = A('').member()
-b = None  # type: B
+b: B
 b = B('').member()
 a = B('')
 a = B('').member()
@@ -511,14 +511,14 @@ a = B('').member()
 from typing import NamedTuple, TypeVar
 A = NamedTuple('A', [('x', str)])
 reveal_type(A('hello')._replace(x=''))  # N: Revealed type is "Tuple[builtins.str, fallback=__main__.A]"
-a = None  # type: A
+a: A
 a = A('hello')._replace(x='')
 
 class B(A):
     pass
 
 reveal_type(B('hello')._replace(x=''))  # N: Revealed type is "Tuple[builtins.str, fallback=__main__.B]"
-b = None  # type: B
+b: B
 b = B('hello')._replace(x='')
 [builtins fixtures/tuple.pyi]
 
diff --git a/test-data/unit/check-overloading.test b/test-data/unit/check-overloading.test
index 96fbaa77514e5..4851cc96e6da9 100644
--- a/test-data/unit/check-overloading.test
+++ b/test-data/unit/check-overloading.test
@@ -450,7 +450,8 @@ class C: pass
 from foo import *
 [file foo.pyi]
 from typing import overload
-a, b = None, None # type: (A, B)
+a: A
+b: B
 if int():
     b = f(a) # E: Incompatible types in assignment (expression has type "A", variable has type "B")
 if int():
@@ -492,7 +493,8 @@ class C: pass
 from foo import *
 [file foo.pyi]
 from typing import overload
-a, b = None, None # type: (A, B)
+a: A
+b: B
 if int():
     b = a.f(a) # E: Incompatible types in assignment (expression has type "A", variable has type "B")
 if int():
@@ -514,7 +516,8 @@ class B: pass
 from foo import *
 [file foo.pyi]
 from typing import overload
-a, b = None, None # type: (A, B)
+a: A
+b: B
 if int():
     a = f(a)
 if int():
@@ -549,7 +552,10 @@ from foo import *
 [file foo.pyi]
 from typing import overload, TypeVar, Generic
 t = TypeVar('t')
-ab, ac, b, c = None, None, None, None # type: (A[B], A[C], B, C)
+ab: A[B]
+ac: A[C]
+b: B
+c: C
 if int():
     b = f(ab)
     c = f(ac)
@@ -569,7 +575,8 @@ class C: pass
 from foo import *
 [file foo.pyi]
 from typing import overload
-a, b = None, None # type: (A, B)
+a: A
+b: B
 a = A(a)
 a = A(b)
 a = A(object()) # E: No overload variant of "A" matches argument type "object" \
@@ -589,8 +596,8 @@ class B: pass
 from foo import *
 [file foo.pyi]
 from typing import overload, Callable
-o = None # type: object
-a = None # type: A
+o: object
+a: A
 
 if int():
     a = f # E: Incompatible types in assignment (expression has type overloaded function, variable has type "A")
@@ -607,7 +614,8 @@ class A: pass
 from foo import *
 [file foo.pyi]
 from typing import overload
-t, a = None, None # type: (type, A)
+t: type
+a: A
 
 if int():
     a = A # E: Incompatible types in assignment (expression has type "Type[A]", variable has type "A")
@@ -625,7 +633,8 @@ class B: pass
 from foo import *
 [file foo.pyi]
 from typing import overload
-a, b = None, None # type: int, str
+a: int
+b: str
 if int():
     a = A()[a]
 if int():
@@ -647,7 +656,9 @@ from foo import *
 [file foo.pyi]
 from typing import TypeVar, Generic, overload
 t = TypeVar('t')
-a, b, c = None, None, None # type: (A, B, C[A])
+a: A
+b: B
+c: C[A]
 if int():
     a = c[a]
     b = c[a] # E: Incompatible types in assignment (expression has type "A", variable has type "B")
@@ -761,7 +772,8 @@ from typing import overload
 def f(t: type) -> 'A': pass
 @overload
 def f(t: 'A') -> 'B': pass
-a, b = None, None # type: (A, B)
+a: A
+b: B
 if int():
     a = f(A)
 if int():
@@ -1215,6 +1227,7 @@ f(*(1, '', 1))() # E: No overload variant of "f" matches argument type "Tuple[in
 [builtins fixtures/tuple.pyi]
 
 [case testPreferExactSignatureMatchInOverload]
+# flags: --no-strict-optional
 from foo import *
 [file foo.pyi]
 from typing import overload, List
diff --git a/test-data/unit/check-plugin-attrs.test b/test-data/unit/check-plugin-attrs.test
index 5b8c361906a82..edae6c0960159 100644
--- a/test-data/unit/check-plugin-attrs.test
+++ b/test-data/unit/check-plugin-attrs.test
@@ -672,6 +672,7 @@ class A(Generic[T]):
 [builtins fixtures/classmethod.pyi]
 
 [case testAttrsForwardReference]
+# flags: --no-strict-optional
 import attr
 @attr.s(auto_attribs=True)
 class A:
@@ -687,6 +688,7 @@ A(B(None))
 [builtins fixtures/list.pyi]
 
 [case testAttrsForwardReferenceInClass]
+# flags: --no-strict-optional
 import attr
 @attr.s(auto_attribs=True)
 class A:
@@ -1593,6 +1595,7 @@ def f(t: TA) -> None:
 [builtins fixtures/plugin_attrs.pyi]
 
 [case testNonattrsFields]
+# flags: --no-strict-optional
 from typing import Any, cast, Type
 from attrs import fields
 
diff --git a/test-data/unit/check-statements.test b/test-data/unit/check-statements.test
index 29e2c5ba3266a..8a232d52968ff 100644
--- a/test-data/unit/check-statements.test
+++ b/test-data/unit/check-statements.test
@@ -95,10 +95,10 @@ def f() -> Iterator[int]:
 
 [case testIfStatement]
 
-a = None # type: A
-a2 = None # type: A
-a3 = None # type: A
-b = None # type: bool
+a: A
+a2: A
+a3: A
+b: bool
 if a:
     a = b # E: Incompatible types in assignment (expression has type "bool", variable has type "A")
 elif a2:
@@ -124,8 +124,8 @@ class A: pass
 
 [case testWhileStatement]
 
-a = None # type: A
-b = None # type: bool
+a: A
+b: bool
 while a:
     a = b    # Fail
 else:
@@ -142,13 +142,14 @@ main:7: error: Incompatible types in assignment (expression has type "bool", var
 [case testForStatement]
 class A: pass
 
-a = None # type: A
-b = None # type: object
+a: A
+b: object
 for a in [A()]:
     a = b  # E: Incompatible types in assignment (expression has type "object", variable has type "A")
 else:
     a = b  # E: Incompatible types in assignment (expression has type "object", variable has type "A")
 [builtins fixtures/list.pyi]
+
 [case testBreakStatement]
 import typing
 while None:
@@ -205,8 +206,9 @@ for a, b in x:  # type: int, int, int  # E: Incompatible number of tuple items
 
 
 [case testPlusAssign]
-
-a, b, c = None, None, None # type: (A, B, C)
+a: A
+b: B
+c: C
 a += b   # Fail
 b += a   # Fail
 c += a   # Fail
@@ -221,13 +223,14 @@ class B:
 class C: pass
 [builtins fixtures/tuple.pyi]
 [out]
-main:3: error: Unsupported operand types for + ("A" and "B")
-main:4: error: Incompatible types in assignment (expression has type "C", variable has type "B")
-main:5: error: Unsupported left operand type for + ("C")
+main:4: error: Unsupported operand types for + ("A" and "B")
+main:5: error: Incompatible types in assignment (expression has type "C", variable has type "B")
+main:6: error: Unsupported left operand type for + ("C")
 
 [case testMinusAssign]
-
-a, b, c = None, None, None # type: (A, B, C)
+a: A
+b: B
+c: C
 a -= b   # Fail
 b -= a   # Fail
 c -= a   # Fail
@@ -242,13 +245,13 @@ class B:
 class C: pass
 [builtins fixtures/tuple.pyi]
 [out]
-main:3: error: Unsupported operand types for - ("A" and "B")
-main:4: error: Incompatible types in assignment (expression has type "C", variable has type "B")
-main:5: error: Unsupported left operand type for - ("C")
+main:4: error: Unsupported operand types for - ("A" and "B")
+main:5: error: Incompatible types in assignment (expression has type "C", variable has type "B")
+main:6: error: Unsupported left operand type for - ("C")
 
 [case testMulAssign]
-
-a, c = None, None # type: (A, C)
+a: A
+c: C
 a *= a   # Fail
 c *= a   # Fail
 a *= c
@@ -263,7 +266,8 @@ main:3: error: Unsupported operand types for * ("A" and "A")
 main:4: error: Unsupported left operand type for * ("C")
 
 [case testMatMulAssign]
-a, c = None, None # type: (A, C)
+a: A
+c: C
 a @= a   # E: Unsupported operand types for @ ("A" and "A")
 c @= a   # E: Unsupported left operand type for @ ("C")
 a @= c
@@ -275,8 +279,8 @@ class C: pass
 [builtins fixtures/tuple.pyi]
 
 [case testDivAssign]
-
-a, c = None, None # type: (A, C)
+a: A
+c: C
 a /= a   # Fail
 c /= a   # Fail
 a /= c
@@ -291,8 +295,8 @@ main:3: error: Unsupported operand types for / ("A" and "A")
 main:4: error: Unsupported left operand type for / ("C")
 
 [case testPowAssign]
-
-a, c = None, None # type: (A, C)
+a: A
+c: C
 a **= a   # Fail
 c **= a   # Fail
 a **= c
@@ -307,8 +311,8 @@ main:3: error: Unsupported operand types for ** ("A" and "A")
 main:4: error: Unsupported left operand type for ** ("C")
 
 [case testSubtypesInOperatorAssignment]
-
-a, b = None, None # type: (A, B)
+a: A
+b: B
 b += b
 b += a
 a += b
@@ -321,8 +325,8 @@ class B(A): pass
 [out]
 
 [case testAdditionalOperatorsInOpAssign]
-
-a, c = None, None # type: (A, C)
+a: A
+c: C
 a &= a  # Fail
 a >>= a # Fail
 a //= a # Fail
@@ -389,9 +393,9 @@ main:2: error: Unsupported left operand type for + ("None")
 
 [case testRaiseStatement]
 
-e = None # type: BaseException
-f = None # type: MyError
-a = None # type: A
+e: BaseException
+f: MyError
+a: A
 raise a # Fail
 raise e
 raise f
@@ -441,7 +445,7 @@ raise MyKwError  # E: Missing named argument "kwonly" for "MyKwError"
 
 [case testRaiseExceptionType]
 import typing
-x = None # type: typing.Type[BaseException]
+x: typing.Type[BaseException]
 raise x
 [builtins fixtures/exception.pyi]
 
@@ -453,21 +457,21 @@ raise x # E: Exception must be derived from BaseException
 
 [case testRaiseUnion]
 import typing
-x = None # type: typing.Union[BaseException, typing.Type[BaseException]]
+x: typing.Union[BaseException, typing.Type[BaseException]]
 raise x
 [builtins fixtures/exception.pyi]
 
 [case testRaiseNonExceptionUnionFails]
 import typing
-x = None # type: typing.Union[BaseException, int]
+x: typing.Union[BaseException, int]
 raise x # E: Exception must be derived from BaseException
 [builtins fixtures/exception.pyi]
 
 [case testRaiseFromStatement]
-e = None # type: BaseException
-f = None # type: MyError
-a = None # type: A
-x = None # type: BaseException
+e: BaseException
+f: MyError
+a: A
+x: BaseException
 del x
 raise e from a # E: Exception must be derived from BaseException
 raise e from e
@@ -505,27 +509,30 @@ main:5: error: Incompatible types in assignment (expression has type "object", v
 try:
   pass
 except BaseException as e:
-  a, o = None, None # type: (BaseException, object)
+  a: BaseException
+  o: object
   e = a
   e = o # Fail
 class A: pass
 class B: pass
 [builtins fixtures/exception.pyi]
 [out]
-main:7: error: Incompatible types in assignment (expression has type "object", variable has type "BaseException")
+main:8: error: Incompatible types in assignment (expression has type "object", variable has type "BaseException")
 
 [case testTypeErrorInBlock]
 class A: pass
 class B: pass
-while object:
-    x = None # type: A
+while int():
+    x: A
     if int():
         x = object() # E: Incompatible types in assignment (expression has type "object", variable has type "A")
         x = B() # E: Incompatible types in assignment (expression has type "B", variable has type "A")
+
 [case testTypeErrorInvolvingBaseException]
 class A: pass
 
-x, a = None, None # type: (BaseException, A)
+x: BaseException
+a: A
 if int():
     a = BaseException()  # E: Incompatible types in assignment (expression has type "BaseException", variable has type "A")
 if int():
@@ -1042,7 +1049,8 @@ main:12: error: Exception type must be derived from BaseException (or be a tuple
 
 
 [case testDelStmtWithIndex]
-a, b = None, None # type: (A, B)
+a: A
+b: B
 del b[a]
 del b[b] # E: Argument 1 to "__delitem__" of "B" has incompatible type "B"; expected "A"
 del a[a] # E: "A" has no attribute "__delitem__"
@@ -1965,6 +1973,7 @@ def f() -> None:
 [out]
 
 [case testChainedAssignmentWithType]
+# flags: --no-strict-optional
 x = y = None # type: int
 if int():
     x = '' # E: Incompatible types in assignment (expression has type "str", variable has type "int")
@@ -1982,7 +1991,8 @@ if int():
 
 [case testAssignListToStarExpr]
 from typing import List
-bs, cs = None, None # type: List[A], List[B]
+bs: List[A]
+cs: List[B]
 if int():
     *bs, b = bs
 if int():
diff --git a/test-data/unit/check-tuples.test b/test-data/unit/check-tuples.test
index f8d6573a56fe4..5cb89a6854be7 100644
--- a/test-data/unit/check-tuples.test
+++ b/test-data/unit/check-tuples.test
@@ -4,11 +4,11 @@
 
 [case testTupleAssignmentWithTupleTypes]
 from typing import Tuple
-t1 = None # type: Tuple[A]
-t2 = None # type: Tuple[B]
-t3 = None # type: Tuple[A, A]
-t4 = None # type: Tuple[A, B]
-t5 = None # type: Tuple[B, A]
+t1: Tuple[A]
+t2: Tuple[B]
+t3: Tuple[A, A]
+t4: Tuple[A, B]
+t5: Tuple[B, A]
 
 if int():
     t1 = t2 # E: Incompatible types in assignment (expression has type "Tuple[B]", variable has type "Tuple[A]")
@@ -39,9 +39,9 @@ class B: pass
 
 [case testTupleSubtyping]
 from typing import Tuple
-t1 = None # type: Tuple[A, A]
-t2 = None # type: Tuple[A, B]
-t3 = None # type: Tuple[B, A]
+t1: Tuple[A, A]
+t2: Tuple[A, B]
+t3: Tuple[B, A]
 
 if int():
     t2 = t1  # E: Incompatible types in assignment (expression has type "Tuple[A, A]", variable has type "Tuple[A, B]")
@@ -57,6 +57,7 @@ class B(A): pass
 [builtins fixtures/tuple.pyi]
 
 [case testTupleCompatibilityWithOtherTypes]
+# flags: --no-strict-optional
 from typing import Tuple
 a, o = None, None # type: (A, object)
 t = None # type: Tuple[A, A]
@@ -80,8 +81,8 @@ class A: pass
 
 [case testNestedTupleTypes]
 from typing import Tuple
-t1 = None # type: Tuple[A, Tuple[A, A]]
-t2 = None # type: Tuple[B, Tuple[B, B]]
+t1: Tuple[A, Tuple[A, A]]
+t2: Tuple[B, Tuple[B, B]]
 
 if int():
     t2 = t1 # E: Incompatible types in assignment (expression has type "Tuple[A, Tuple[A, A]]", variable has type "Tuple[B, Tuple[B, B]]")
@@ -94,8 +95,8 @@ class B(A): pass
 
 [case testNestedTupleTypes2]
 from typing import Tuple
-t1 = None # type: Tuple[A, Tuple[A, A]]
-t2 = None # type: Tuple[B, Tuple[B, B]]
+t1: Tuple[A, Tuple[A, A]]
+t2: Tuple[B, Tuple[B, B]]
 
 if int():
     t2 = t1 # E: Incompatible types in assignment (expression has type "Tuple[A, Tuple[A, A]]", variable has type "Tuple[B, Tuple[B, B]]")
@@ -108,8 +109,8 @@ class B(A): pass
 
 [case testSubtypingWithNamedTupleType]
 from typing import Tuple
-t1 = None # type: Tuple[A, A]
-t2 = None # type: tuple
+t1: Tuple[A, A]
+t2: tuple
 
 if int():
     t1 = t2 # E: Incompatible types in assignment (expression has type "Tuple[Any, ...]", variable has type "Tuple[A, A]")
@@ -120,6 +121,7 @@ class A: pass
 [builtins fixtures/tuple.pyi]
 
 [case testTupleInitializationWithNone]
+# flags: --no-strict-optional
 from typing import Tuple
 t = None # type: Tuple[A, A]
 t = None
@@ -132,6 +134,7 @@ class A: pass
 
 
 [case testTupleExpressions]
+# flags: --no-strict-optional
 from typing import Tuple
 t1 = None # type: tuple
 t2 = None # type: Tuple[A]
@@ -177,12 +180,13 @@ def f() -> None: pass
 
 [case testIndexingTuples]
 from typing import Tuple
-t1 = None # type: Tuple[A, B]
-t2 = None # type: Tuple[A]
-t3 = None # type: Tuple[A, B, C, D, E]
-a, b = None, None # type: (A, B)
-x = None # type: Tuple[A, B, C]
-y = None # type: Tuple[A, C, E]
+t1: Tuple[A, B]
+t2: Tuple[A]
+t3: Tuple[A, B, C, D, E]
+a: A
+b: B
+x: Tuple[A, B, C]
+y: Tuple[A, C, E]
 n = 0
 
 if int():
@@ -221,9 +225,10 @@ class E: pass
 
 [case testIndexingTuplesWithNegativeIntegers]
 from typing import Tuple
-t1 = None  # type: Tuple[A, B]
-t2 = None  # type: Tuple[A]
-a, b = None, None  # type: A, B
+t1: Tuple[A, B]
+t2: Tuple[A]
+a: A
+b: B
 
 if int():
     a = t1[-1] # E: Incompatible types in assignment (expression has type "B", variable has type "A")
@@ -251,7 +256,7 @@ from typing import Tuple
 class A: pass
 class B: pass
 
-t = None # type: Tuple[A, B]
+t: Tuple[A, B]
 n = 0
 
 t[0] = A() # E: Unsupported target for indexed assignment ("Tuple[A, B]")
@@ -265,6 +270,7 @@ t[n] = A() # E: Unsupported target for indexed assignment ("Tuple[A, B]")
 
 
 [case testMultipleAssignmentWithTuples]
+# flags: --no-strict-optional
 from typing import Tuple
 t1 = None # type: Tuple[A, B]
 t2 = None # type: Tuple[A, B, A]
@@ -291,6 +297,7 @@ class B: pass
 [builtins fixtures/tuple.pyi]
 
 [case testMultipleAssignmentWithSquareBracketTuples]
+# flags: --no-strict-optional
 from typing import Tuple
 
 def avoid_confusing_test_parser() -> None:
@@ -322,8 +329,8 @@ class B: pass
 
 [case testMultipleAssignmentWithInvalidNumberOfValues]
 from typing import Tuple
-t1 = None # type: Tuple[A, A, A]
-a = None # type: A
+t1: Tuple[A, A, A]
+a: A
 
 a, a = t1       # E: Too many values to unpack (2 expected, 3 provided)
 a, a, a, a = t1 # E: Need more than 3 values to unpack (4 expected)
@@ -334,8 +341,8 @@ class A: pass
 [builtins fixtures/tuple.pyi]
 
 [case testMultipleAssignmentWithTupleExpressionRvalue]
-
-a, b = None, None # type: (A, B)
+a: A
+b: B
 
 if int():
     a, b = a, a # E: Incompatible types in assignment (expression has type "A", variable has type "B")
@@ -354,7 +361,8 @@ class B: pass
 [builtins fixtures/tuple.pyi]
 
 [case testSubtypingInMultipleAssignment]
-a, b = None, None # type: (A, B)
+a: A
+b: B
 
 if int():
     b, b = a, b # E: Incompatible types in assignment (expression has type "A", variable has type "B")
@@ -371,7 +379,7 @@ class B(A): pass
 [builtins fixtures/tuple.pyi]
 
 [case testInitializationWithMultipleValues]
-
+# flags: --no-strict-optional
 a, b = None, None # type: (A, B)
 
 a1, b1 = a, a # type: (A, B)  # E: Incompatible types in assignment (expression has type "A", variable has type "B")
@@ -387,8 +395,8 @@ class B: pass
 [builtins fixtures/tuple.pyi]
 
 [case testMultipleAssignmentWithNonTupleRvalue]
-
-a, b = None, None # type: (A, B)
+a: A
+b: B
 def f(): pass
 
 a, b = None # E: "None" object is not iterable
@@ -400,9 +408,10 @@ class B: pass
 [builtins fixtures/tuple.pyi]
 
 [case testMultipleAssignmentWithIndexedLvalues]
-
-a, b = None, None # type: (A, B)
-aa, bb = None, None # type: (AA, BB)
+a: A
+b: B
+aa: AA
+bb: BB
 
 a[a], b[b] = a, bb   # E: Incompatible types in assignment (expression has type "A", target has type "AA")
 a[a], b[b] = aa, b   # E: Incompatible types in assignment (expression has type "B", target has type "BB")
@@ -420,6 +429,7 @@ class BB: pass
 [builtins fixtures/tuple.pyi]
 
 [case testMultipleDeclarationWithParentheses]
+# flags: --no-strict-optional
 (a, b) = (None, None) # type: int, str
 if int():
     a = '' # E: Incompatible types in assignment (expression has type "str", variable has type "int")
@@ -430,8 +440,8 @@ if int():
 [builtins fixtures/tuple.pyi]
 
 [case testMultipleAssignmentWithExtraParentheses]
-
-a, b = None, None # type: (A, B)
+a: A
+b: B
 
 if int():
     (a, b) = (a, a) # E: Incompatible types in assignment (expression has type "A", variable has type "B")
@@ -458,6 +468,7 @@ class B: pass
 [builtins fixtures/tuple.pyi]
 
 [case testMultipleAssignmentUsingSingleTupleType]
+# flags: --no-strict-optional
 from typing import Tuple
 a, b = None, None  # type: Tuple[int, str]
 if int():
@@ -490,6 +501,7 @@ aa, bb, *cc = t  # E: Need type annotation for "cc" (hint: "cc: List[<type>] = .
 [builtins fixtures/list.pyi]
 
 [case testAssignmentToStarAnnotation]
+# flags: --no-strict-optional
 from typing import List
 li, lo = None, None # type: List[int], List[object]
 a, b, *c = 1, 2  # type: int, int, List[int]
@@ -501,7 +513,7 @@ if int():
 
 [case testAssignmentToStarCount1]
 from typing import List
-ca = None # type: List[int]
+ca: List[int]
 c = [1]
 if int():
     a, b, *c = 1,  # E: Need more than 1 value to unpack (2 expected)
@@ -515,7 +527,7 @@ if int():
 
 [case testAssignmentToStarCount2]
 from typing import List
-ca = None # type: List[int]
+ca: List[int]
 t1 = 1,
 t2 = 1, 2
 t3 = 1, 2, 3
@@ -541,7 +553,7 @@ c = a
 c = q
 [case testAssignmentToComplexStar]
 from typing import List
-li = None # type: List[int]
+li: List[int]
 if int():
     a, *(li) = 1,
 a, *(b, c) = 1, 2  # E: Need more than 1 value to unpack (2 expected)
@@ -553,9 +565,9 @@ if int():
 
 [case testAssignmentToStarFromTupleType]
 from typing import List, Tuple
-li = None # type: List[int]
-la = None # type: List[A]
-ta = None # type: Tuple[A, A, A]
+li: List[int]
+la: List[A]
+ta: Tuple[A, A, A]
 if int():
     a, *la = ta
 if int():
@@ -573,8 +585,8 @@ class A: pass
 [case testAssignmentToStarFromTupleInference]
 from typing import List
 class A: pass
-li = None # type: List[int]
-la = None # type: List[A]
+li: List[int]
+la: List[A]
 a, *l = A(), A()
 if int():
     l = li  # E: Incompatible types in assignment (expression has type "List[int]", variable has type "List[A]")
@@ -588,8 +600,8 @@ from typing import List
 
 class A: pass
 
-li = None # type: List[int]
-la = None # type: List[A]
+li: List[int]
+la: List[A]
 a, *l = [A(), A()]
 if int():
     l = li  # E: Incompatible types in assignment (expression has type "List[int]", variable has type "List[A]")
@@ -600,9 +612,9 @@ if int():
 
 [case testAssignmentToStarFromTupleTypeInference]
 from typing import List, Tuple
-li = None # type: List[int]
-la = None # type: List[A]
-ta = None # type: Tuple[A, A, A]
+li: List[int]
+la: List[A]
+ta: Tuple[A, A, A]
 a, *l = ta
 if int():
     l = li  # E: Incompatible types in assignment (expression has type "List[int]", variable has type "List[A]")
@@ -615,8 +627,8 @@ class A: pass
 
 [case testAssignmentToStarFromListTypeInference]
 from typing import List
-li = None # type: List[int]
-la = None # type: List[A]
+li: List[int]
+la: List[A]
 a, *l = la
 if int():
     l = li  # E: Incompatible types in assignment (expression has type "List[int]", variable has type "List[A]")
@@ -656,9 +668,12 @@ reveal_type(e2)  # N: Revealed type is "builtins.list[builtins.int]"
 
 
 [case testNestedTupleAssignment1]
-
-a1, b1, c1 = None, None, None # type: (A, B, C)
-a2, b2, c2 = None, None, None # type: (A, B, C)
+a1: A
+a2: A
+b1: B
+b2: B
+c1: C
+c2: C
 
 if int():
     a1, (b1, c1) = a2, (b2, c2)
@@ -673,9 +688,12 @@ class C: pass
 [builtins fixtures/tuple.pyi]
 
 [case testNestedTupleAssignment2]
-
-a1, b1, c1 = None, None, None # type: (A, B, C)
-a2, b2, c2 = None, None, None # type: (A, B, C)
+a1: A
+a2: A
+b1: B
+b2: B
+c1: C
+c2: C
 t = a1, b1
 
 if int():
@@ -714,7 +732,7 @@ class A:
     def __add__(self, x: 'A') -> 'A': pass
 def f(x: 'A') -> None: pass
 
-a = None # type: A
+a: A
 
 (a, a) + a  # E: Unsupported operand types for + ("Tuple[A, A]" and "A")
 a + (a, a)  # E: Unsupported operand types for + ("A" and "Tuple[A, A]")
@@ -724,7 +742,7 @@ f((a, a))   # E: Argument 1 to "f" has incompatible type "Tuple[A, A]"; expected
 
 [case testLargeTuplesInErrorMessages]
 
-a = None # type: LongTypeName
+a: LongTypeName
 a + (a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a) # Fail
 
 class LongTypeName:
@@ -740,7 +758,7 @@ main:3: error: Unsupported operand types for + ("LongTypeName" and "Tuple[LongTy
 
 [case testTupleMethods]
 from typing import Tuple
-t = None # type: Tuple[int, str]
+t: Tuple[int, str]
 i = 0
 s = ''
 b = bool()
@@ -869,7 +887,7 @@ class A(tuple): pass
 import m
 [file m.pyi]
 from typing import Tuple
-a = None # type: A
+a: A
 class A(Tuple[int, str]): pass
 x, y = a
 x() # E: "int" not callable
@@ -932,14 +950,14 @@ fb(aa) # E: Argument 1 to "fb" has incompatible type "Tuple[A, A]"; expected "Tu
 
 [case testSubtypingTupleIsContainer]
 from typing import Container
-a = None  # type: Container[str]
+a: Container[str]
 a = ()
 [typing fixtures/typing-full.pyi]
 [builtins fixtures/tuple.pyi]
 
 [case testSubtypingTupleIsSized]
 from typing import Sized
-a = None  # type: Sized
+a: Sized
 a = ()
 [typing fixtures/typing-medium.pyi]
 [builtins fixtures/tuple.pyi]
@@ -1046,8 +1064,8 @@ class B1(A): pass
 class B2(A): pass
 class C: pass
 
-x = None # type: Tuple[A, ...]
-y = None # type: Tuple[Union[B1, C], Union[B2, C]]
+x: Tuple[A, ...]
+y: Tuple[Union[B1, C], Union[B2, C]]
 
 def g(x: T) -> Tuple[T, T]:
     return (x, x)
@@ -1063,13 +1081,13 @@ from typing import Tuple
 class A: pass
 class B(A): pass
 
-fixtup = None  # type: Tuple[B, B]
+fixtup: Tuple[B, B]
 
-vartup_b = None  # type: Tuple[B, ...]
+vartup_b: Tuple[B, ...]
 reveal_type(fixtup if int() else vartup_b)  # N: Revealed type is "builtins.tuple[__main__.B, ...]"
 reveal_type(vartup_b if int() else fixtup)  # N: Revealed type is "builtins.tuple[__main__.B, ...]"
 
-vartup_a = None  # type: Tuple[A, ...]
+vartup_a: Tuple[A, ...]
 reveal_type(fixtup if int() else vartup_a)  # N: Revealed type is "builtins.tuple[__main__.A, ...]"
 reveal_type(vartup_a if int() else fixtup)  # N: Revealed type is "builtins.tuple[__main__.A, ...]"
 
@@ -1083,13 +1101,13 @@ from typing import Tuple, List
 class A: pass
 class B(A): pass
 
-fixtup = None  # type: Tuple[B, B]
+fixtup: Tuple[B, B]
 
-lst_b = None  # type: List[B]
+lst_b: List[B]
 reveal_type(fixtup if int() else lst_b)  # N: Revealed type is "typing.Sequence[__main__.B]"
 reveal_type(lst_b if int() else fixtup)  # N: Revealed type is "typing.Sequence[__main__.B]"
 
-lst_a = None  # type: List[A]
+lst_a: List[A]
 reveal_type(fixtup if int() else lst_a)  # N: Revealed type is "typing.Sequence[__main__.A]"
 reveal_type(lst_a if int() else fixtup)  # N: Revealed type is "typing.Sequence[__main__.A]"
 
@@ -1103,15 +1121,15 @@ class A: pass
 
 empty = ()
 
-fixtup = None  # type: Tuple[A]
+fixtup: Tuple[A]
 reveal_type(fixtup if int() else empty)  # N: Revealed type is "builtins.tuple[__main__.A, ...]"
 reveal_type(empty if int() else fixtup)  # N: Revealed type is "builtins.tuple[__main__.A, ...]"
 
-vartup = None  # type: Tuple[A, ...]
+vartup: Tuple[A, ...]
 reveal_type(empty if int() else vartup)  # N: Revealed type is "builtins.tuple[__main__.A, ...]"
 reveal_type(vartup if int() else empty)  # N: Revealed type is "builtins.tuple[__main__.A, ...]"
 
-lst = None  # type: List[A]
+lst: List[A]
 reveal_type(empty if int() else lst)  # N: Revealed type is "typing.Sequence[__main__.A]"
 reveal_type(lst if int() else empty)  # N: Revealed type is "typing.Sequence[__main__.A]"
 
@@ -1128,9 +1146,9 @@ class NTup(NamedTuple):
 class SubTuple(Tuple[bool]): ...
 class SubVarTuple(Tuple[int, ...]): ...
 
-ntup = None  # type: NTup
-subtup = None  # type: SubTuple
-vartup = None  # type: SubVarTuple
+ntup: NTup
+subtup: SubTuple
+vartup: SubVarTuple
 
 reveal_type(ntup if int() else vartup)  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
 reveal_type(subtup if int() else vartup)  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
@@ -1141,8 +1159,8 @@ reveal_type(subtup if int() else vartup)  # N: Revealed type is "builtins.tuple[
 [case testTupleJoinIrregular]
 from typing import Tuple
 
-tup1 = None  # type: Tuple[bool, int]
-tup2 = None  # type: Tuple[bool]
+tup1: Tuple[bool, int]
+tup2: Tuple[bool]
 
 reveal_type(tup1 if int() else tup2)  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
 reveal_type(tup2 if int() else tup1)  # N: Revealed type is "builtins.tuple[builtins.int, ...]"
@@ -1168,9 +1186,9 @@ class NTup2(NamedTuple):
 
 class SubTuple(Tuple[bool, int, int]): ...
 
-tup1 = None  # type: NTup1
-tup2 = None  # type: NTup2
-subtup = None  # type: SubTuple
+tup1: NTup1
+tup2: NTup2
+subtup: SubTuple
 
 reveal_type(tup1 if int() else tup2)  # N: Revealed type is "builtins.tuple[builtins.bool, ...]"
 reveal_type(tup2 if int() else tup1)  # N: Revealed type is "builtins.tuple[builtins.bool, ...]"

From d106c847904ac84d92dc828de5057d80e8774c44 Mon Sep 17 00:00:00 2001
From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
Date: Fri, 7 Jul 2023 18:11:09 +0200
Subject: [PATCH 128/129] Enable strict optional for more test files (9)
 (#15607)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Followup to https://github.com/python/mypy/pull/15586

This will be the last one 🚀
---
 mypy/test/testcheck.py            | 12 +---
 test-data/unit/check-modules.test | 21 +++++--
 test-data/unit/check-unions.test  | 44 ++++++++-------
 test-data/unit/check-varargs.test | 92 ++++++++++++++++++-------------
 4 files changed, 93 insertions(+), 76 deletions(-)

diff --git a/mypy/test/testcheck.py b/mypy/test/testcheck.py
index a77da090f7405..20dfbb77f3e04 100644
--- a/mypy/test/testcheck.py
+++ b/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]
diff --git a/test-data/unit/check-modules.test b/test-data/unit/check-modules.test
index 8a30237843a5a..fc3daff64fbd7 100644
--- a/test-data/unit/check-modules.test
+++ b/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]
diff --git a/test-data/unit/check-unions.test b/test-data/unit/check-unions.test
index 65d5c1abc7e8c..28d83aa54cccd 100644
--- a/test-data/unit/check-unions.test
+++ b/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):
diff --git a/test-data/unit/check-varargs.test b/test-data/unit/check-varargs.test
index 92b9f7f04f26b..4da9e0e5033ef 100644
--- a/test-data/unit/check-varargs.test
+++ b/test-data/unit/check-varargs.test
@@ -8,8 +8,8 @@
 [case testVarArgsWithinFunction]
 from typing import Tuple
 def f( *b: 'B') -> None:
-    ab = None # type: Tuple[B, ...]
-    ac = None # type: Tuple[C, ...]
+    ab: Tuple[B, ...]
+    ac: Tuple[C, ...]
     if int():
         b = ac # E: Incompatible types in assignment (expression has type "Tuple[C, ...]", variable has type "Tuple[B, ...]")
         ac = b # E: Incompatible types in assignment (expression has type "Tuple[B, ...]", variable has type "Tuple[C, ...]")
@@ -46,9 +46,9 @@ class A: pass
 class B(A): pass
 class C: pass
 
-a = None # type: A
-b = None # type: B
-c = None # type: C
+a: A
+b: B
+c: C
 
 f(c)       # E: Argument 1 to "f" has incompatible type "C"; expected "A"
 f(a, b, c) # E: Argument 3 to "f" has incompatible type "C"; expected "A"
@@ -67,9 +67,9 @@ class A: pass
 class B(A): pass
 class C: pass
 
-a = None # type: A
-b = None # type: B
-c = None # type: C
+a: A
+b: B
+c: C
 
 f(a)       # E: Argument 1 to "f" has incompatible type "A"; expected "C"
 f(c, c)    # E: Argument 2 to "f" has incompatible type "C"; expected "A"
@@ -88,9 +88,9 @@ class A: pass
 class B(A): pass
 class C: pass
 
-a = None # type: A
-b = None # type: B
-c = None # type: C
+a: A
+b: B
+c: C
 
 f(a)           # E: Argument 1 to "f" has incompatible type "A"; expected "Optional[C]"
 f(c, c)        # E: Argument 2 to "f" has incompatible type "C"; expected "A"
@@ -103,8 +103,8 @@ f(c, b, b, a, b)
 
 [case testCallVarargsFunctionWithIterable]
 from typing import Iterable
-it1 = None  # type: Iterable[int]
-it2 = None  # type: Iterable[str]
+it1: Iterable[int]
+it2: Iterable[str]
 def f(*x: int) -> None: pass
 f(*it1)
 f(*it2) # E: Argument 1 to "f" has incompatible type "*Iterable[str]"; expected "int"
@@ -127,7 +127,7 @@ reveal_type(f(*x, *y)) # N: Revealed type is "Tuple[builtins.int, builtins.str,
 [case testCallVarargsFunctionWithIterableAndPositional]
 
 from typing import Iterable
-it1 = None  # type: Iterable[int]
+it1: Iterable[int]
 def f(*x: int) -> None: pass
 f(*it1, 1, 2)
 f(*it1, 1, *it1, 2)
@@ -161,10 +161,10 @@ class A: pass
 class B(A): pass
 class C: pass
 
-a = None # type: A
-b = None # type: B
-c = None # type: C
-o = None # type: object
+a: A
+b: B
+c: C
+o: object
 
 if int():
     a = f(o) # E: Incompatible types in assignment (expression has type "object", variable has type "A")
@@ -188,6 +188,7 @@ if int():
 [builtins fixtures/list.pyi]
 
 [case testTypeInferenceWithCalleeVarArgsAndDefaultArgs]
+# flags: --no-strict-optional
 from typing import TypeVar
 T = TypeVar('T')
 a = None # type: A
@@ -229,10 +230,10 @@ def f(a: 'A', b: 'B') -> None:
 class A: pass
 class B: pass
 
-aa = None # type: List[A]
-ab = None # type: List[B]
-a = None # type: A
-b = None # type: B
+aa: List[A]
+ab: List[B]
+a: A
+b: B
 
 f(*aa)  # E: Argument 1 to "f" has incompatible type "*List[A]"; expected "B"
 f(a, *ab) # Ok
@@ -248,10 +249,10 @@ class B: pass
 class C: pass
 class CC(C): pass
 
-a = None # type: A
-b = None # type: B
-c = None # type: C
-cc = None # type: CC
+a: A
+b: B
+c: C
+cc: CC
 
 f(*(a, b, b)) # E: Argument 1 to "f" has incompatible type "*Tuple[A, B, B]"; expected "C"
 f(*(b, b, c)) # E: Argument 1 to "f" has incompatible type "*Tuple[B, B, C]"; expected "A"
@@ -267,7 +268,7 @@ f(a, *(b, cc))
 [builtins fixtures/tuple.pyi]
 
 [case testInvalidVarArg]
-
+# flags: --no-strict-optional
 def f(a: 'A') -> None:
     pass
 
@@ -293,7 +294,10 @@ def g(a: 'A', *b: 'A') -> None: pass
 class A: pass
 class B: pass
 
-aa, ab, a, b = None, None, None, None # type: (List[A], List[B], A, B)
+aa: List[A]
+ab: List[B]
+a: A
+b: B
 f(*aa)           # E: Argument 1 to "f" has incompatible type "*List[A]"; expected "B"
 f(a, *aa)        # E: Argument 2 to "f" has incompatible type "*List[A]"; expected "B"
 f(b, *ab)        # E: Argument 1 to "f" has incompatible type "B"; expected "A"
@@ -315,7 +319,10 @@ class B: pass
 class C: pass
 class CC(C): pass
 
-a, b, c, cc = None, None, None, None # type: (A, B, C, CC)
+a: A
+b: B
+c: C
+cc: CC
 
 f(*(b, b, b))   # E: Argument 1 to "f" has incompatible type "*Tuple[B, B, B]"; expected "A"
 f(*(a, a, b))   # E: Argument 1 to "f" has incompatible type "*Tuple[A, A, B]"; expected "B"
@@ -342,7 +349,8 @@ def f(a: 'A') -> None: pass
 def g(a: 'A', *b: 'A') -> None: pass
 class A: pass
 
-d, a = None, None # type: (Any, A)
+d: Any
+a: A
 f(a, a, *d) # E: Too many arguments for "f"
 f(a, *d)    # Ok
 f(*d)       # Ok
@@ -351,6 +359,7 @@ g(*d)
 g(a, *d)
 g(a, a, *d)
 [builtins fixtures/list.pyi]
+
 [case testListVarArgsAndSubtyping]
 from typing import List
 def f( *a: 'A') -> None:
@@ -362,8 +371,8 @@ def g( *a: 'B') -> None:
 class A: pass
 class B(A): pass
 
-aa = None # type: List[A]
-ab = None # type: List[B]
+aa: List[A]
+ab: List[B]
 
 g(*aa) # E: Argument 1 to "g" has incompatible type "*List[A]"; expected "B"
 f(*aa)
@@ -449,6 +458,7 @@ foo(*())
 
 
 [case testIntersectionTypesAndVarArgs]
+# flags: --no-strict-optional
 from foo import *
 [file foo.pyi]
 from typing import overload
@@ -518,7 +528,9 @@ def f(a: S, *b: T) -> Tuple[S, T]:
 class A: pass
 class B: pass
 
-a, b, aa = None, None, None # type: (A, B, List[A])
+a: A
+b: B
+aa: List[A]
 
 if int():
     a, b = f(*aa)    # E: Argument 1 to "f" has incompatible type "*List[A]"; expected "B"
@@ -553,7 +565,8 @@ def f(a: S, b: T) -> Tuple[S, T]: pass
 class A: pass
 class B: pass
 
-a, b = None, None # type: (A, B)
+a: A
+b: B
 
 if int():
     a, a = f(*(a, b))   # E: Argument 1 to "f" has incompatible type "*Tuple[A, B]"; expected "A"
@@ -575,10 +588,11 @@ if int():
 from typing import List, TypeVar, Generic, Tuple
 T = TypeVar('T')
 S = TypeVar('S')
-a, b = None, None # type: (A, B)
-ao = None # type: List[object]
-aa = None # type: List[A]
-ab = None # type: List[B]
+a: A
+b: B
+ao: List[object]
+aa: List[A]
+ab: List[B]
 
 class G(Generic[T]):
     def f(self, *a: S) -> Tuple[List[S], List[T]]:
@@ -649,7 +663,7 @@ f(1, '') # E: Argument 2 to "f" has incompatible type "str"; expected "int"
 
 [case testVarArgsFunctionSubtyping]
 from typing import Callable
-x = None # type: Callable[[int], None]
+x: Callable[[int], None]
 def f(*x: int) -> None: pass
 def g(*x: str) -> None: pass
 x = f

From 6cd8c00983a294b4b142ee0f01e91912363d3450 Mon Sep 17 00:00:00 2001
From: Marc Mueller <30130371+cdce8p@users.noreply.github.com>
Date: Fri, 7 Jul 2023 20:40:01 +0200
Subject: [PATCH 129/129] Enable strict optional for more test files (3)
 (#15597)

---
 mypy/test/helpers.py                     | 11 ++----
 mypy/test/testfinegrained.py             |  7 +---
 test-data/unit/fine-grained-suggest.test |  2 +-
 test-data/unit/fine-grained.test         | 46 +++++++++++++-----------
 4 files changed, 30 insertions(+), 36 deletions(-)

diff --git a/mypy/test/helpers.py b/mypy/test/helpers.py
index 1e034f94dd927..d2c92614048ad 100644
--- a/mypy/test/helpers.py
+++ b/mypy/test/helpers.py
@@ -7,7 +7,7 @@
 import shutil
 import sys
 import time
-from typing import Any, Callable, Collection, Iterable, Iterator, Pattern
+from typing import Any, Callable, Iterable, Iterator, Pattern
 
 # Exporting Suite as alias to TestCase for backwards compatibility
 # TODO: avoid aliasing - import and subclass TestCase directly
@@ -317,10 +317,7 @@ def assert_type(typ: type, value: object) -> None:
 
 
 def parse_options(
-    program_text: str,
-    testcase: DataDrivenTestCase,
-    incremental_step: int,
-    no_strict_optional_files: Collection[str] = (),
+    program_text: str, testcase: DataDrivenTestCase, incremental_step: int
 ) -> Options:
     """Parse comments like '# flags: --foo' in a test case."""
     options = Options()
@@ -342,10 +339,6 @@ def parse_options(
     else:
         flag_list = []
         options = Options()
-        # TODO: Enable strict optional in test cases by default (requires *many* test case changes)
-        if os.path.basename(testcase.file) in no_strict_optional_files:
-            options.strict_optional = False
-
         options.error_summary = False
         options.hide_error_codes = True
         options.force_uppercase_builtins = True
diff --git a/mypy/test/testfinegrained.py b/mypy/test/testfinegrained.py
index a1dde823cb5f2..ba0526d325588 100644
--- a/mypy/test/testfinegrained.py
+++ b/mypy/test/testfinegrained.py
@@ -45,9 +45,6 @@
 # Set to True to perform (somewhat expensive) checks for duplicate AST nodes after merge
 CHECK_CONSISTENCY = False
 
-# TODO: Enable strict optional in test cases by default. Remove files here, once test cases are updated
-no_strict_optional_files = {"fine-grained.test", "fine-grained-suggest.test"}
-
 
 class FineGrainedSuite(DataSuite):
     files = find_test_files(
@@ -143,9 +140,7 @@ def run_case(self, testcase: DataDrivenTestCase) -> None:
 
     def get_options(self, source: str, testcase: DataDrivenTestCase, build_cache: bool) -> Options:
         # This handles things like '# flags: --foo'.
-        options = parse_options(
-            source, testcase, incremental_step=1, no_strict_optional_files=no_strict_optional_files
-        )
+        options = parse_options(source, testcase, incremental_step=1)
         options.incremental = True
         options.use_builtins_fixtures = True
         options.show_traceback = True
diff --git a/test-data/unit/fine-grained-suggest.test b/test-data/unit/fine-grained-suggest.test
index a28e3204b93f7..47de16b8d765d 100644
--- a/test-data/unit/fine-grained-suggest.test
+++ b/test-data/unit/fine-grained-suggest.test
@@ -1090,7 +1090,7 @@ optional2(10)
 optional2('test')
 
 def optional3(x: Optional[List[Any]]):
-    assert not x
+    assert x
     return x[0]
 
 optional3(test)
diff --git a/test-data/unit/fine-grained.test b/test-data/unit/fine-grained.test
index 3cb234364a589..7d854bab424c1 100644
--- a/test-data/unit/fine-grained.test
+++ b/test-data/unit/fine-grained.test
@@ -191,7 +191,7 @@ main:3: error: "A" has no attribute "x"
 [case testVariableTypeBecomesInvalid]
 import m
 def f() -> None:
-    a = None # type: m.A
+    a: m.A
 [file m.py]
 class A: pass
 [file m.py.2]
@@ -1724,15 +1724,15 @@ f = 1
 main:1: error: Module "a" has no attribute "f"
 
 [case testDecoratedMethodRefresh]
-from typing import Iterator, Callable, List
+from typing import Iterator, Callable, List, Optional
 from a import f
 import a
 
-def dec(f: Callable[['A'], Iterator[int]]) -> Callable[[int], int]: pass
+def dec(f: Callable[['A'], Optional[Iterator[int]]]) -> Callable[[int], int]: pass
 
 class A:
     @dec
-    def f(self) -> Iterator[int]:
+    def f(self) -> Optional[Iterator[int]]:
         self.x = a.g()  # type: int
         return None
 [builtins fixtures/list.pyi]
@@ -4626,6 +4626,7 @@ class User:
 ==
 
 [case testNoStrictOptionalModule]
+# flags: --no-strict-optional
 import a
 a.y = a.x
 [file a.py]
@@ -4643,9 +4644,10 @@ y: int
 [out]
 ==
 ==
-main:2: error: Incompatible types in assignment (expression has type "Optional[str]", variable has type "int")
+main:3: error: Incompatible types in assignment (expression has type "Optional[str]", variable has type "int")
 
 [case testNoStrictOptionalFunction]
+# flags: --no-strict-optional
 import a
 from typing import Optional
 def f() -> None:
@@ -4666,9 +4668,10 @@ def g(x: str) -> None:
 [out]
 ==
 ==
-main:5: error: Argument 1 to "g" has incompatible type "Optional[int]"; expected "str"
+main:6: error: Argument 1 to "g" has incompatible type "Optional[int]"; expected "str"
 
 [case testNoStrictOptionalMethod]
+# flags: --no-strict-optional
 import a
 from typing import Optional
 class C:
@@ -4693,7 +4696,7 @@ class B:
 [out]
 ==
 ==
-main:6: error: Argument 1 to "g" of "B" has incompatible type "Optional[int]"; expected "str"
+main:7: error: Argument 1 to "g" of "B" has incompatible type "Optional[int]"; expected "str"
 
 [case testStrictOptionalModule]
 # flags: --strict-optional
@@ -5276,10 +5279,11 @@ class I(metaclass=ABCMeta):
     @abstractmethod
     def f(self) -> None: pass
 [file b.py]
+from typing import Optional
 from z import I
 class Foo(I):
     pass
-def x() -> Foo: return None
+def x() -> Optional[Foo]: return None
 [file z.py.2]
 from abc import abstractmethod, ABCMeta
 class I(metaclass=ABCMeta):
@@ -5301,10 +5305,11 @@ class I(metaclass=ABCMeta):
     @abstractmethod
     def f(self) -> None: pass
 [file b.py]
+from typing import Optional
 from a import I
 class Foo(I):
     pass
-def x() -> Foo: return None
+def x() -> Optional[Foo]: return None
 [file a.py.2]
 from abc import abstractmethod, ABCMeta
 class I(metaclass=ABCMeta):
@@ -7769,7 +7774,8 @@ from typing import List
 import b
 class A(b.B):
     def meth(self) -> None:
-        self.x, *self.y = None, None  # type: str, List[str]
+        self.x: str
+        self.y: List[str]
 [file b.py]
 from typing import List
 class B:
@@ -7781,7 +7787,7 @@ class B:
 [builtins fixtures/list.pyi]
 [out]
 ==
-main:5: error: Incompatible types in assignment (expression has type "List[str]", base class "B" defined the type as "List[int]")
+main:6: error: Incompatible types in assignment (expression has type "List[str]", base class "B" defined the type as "List[int]")
 
 [case testLiskovFineVariableCleanDefInMethodNested-only_when_nocache]
 from b import B
@@ -9109,27 +9115,27 @@ import a
 [file a.py]
 # mypy: no-warn-no-return
 
-from typing import List
-def foo() -> List:
+from typing import List, Optional
+def foo() -> Optional[List]:
     20
 
 [file a.py.2]
 # mypy: disallow-any-generics, no-warn-no-return
 
-from typing import List
-def foo() -> List:
+from typing import List, Optional
+def foo() -> Optional[List]:
     20
 
 [file a.py.3]
 # mypy: no-warn-no-return
 
-from typing import List
-def foo() -> List:
+from typing import List, Optional
+def foo() -> Optional[List]:
     20
 
 [file a.py.4]
-from typing import List
-def foo() -> List:
+from typing import List, Optional
+def foo() -> Optional[List]:
     20
 [out]
 ==
@@ -9867,7 +9873,7 @@ x = 0  # Arbitrary change to trigger reprocessing
 [builtins fixtures/dict.pyi]
 [out]
 ==
-a.py:5: note: Revealed type is "def (x: builtins.int) -> builtins.str"
+a.py:5: note: Revealed type is "def (x: builtins.int) -> Union[builtins.str, None]"
 
 [case testTypeVarTupleCached]
 import a